pacnpal/thrillwiki_django_no_react
1
1
Fork 0
mirror of https://github.com/pacnpal/thrillwiki_django_no_react.git synced 2025-12-20 10:51:09 -05:00
Code Issues Packages Projects Releases Wiki Activity

fix: Update import paths to use 'apps' prefix for models and services

Browse Source
This commit is contained in:
pacnpal
2025-09-28 10:50:57 -04:00
parent 1b246eeaa4
commit bf04e4d854
6 changed files with 395 additions and 363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
demo_roadtrip_usage.py
View File

@@ -5,8 +5,8 @@ This script demonstrates real-world scenarios for using the OSM Road Trip Servic
in the ThrillWiki application. in the ThrillWiki application.
""" """
from parks.models import Park from apps.parks.models import Park
from parks.services import RoadTripService from apps.parks.services import RoadTripService
import os import os
import django import django
@@ -14,6 +14,41 @@ import django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "thrillwiki.settings") os.environ.setdefault("DJANGO_SETTINGS_MODULE", "thrillwiki.settings")
django.setup() django.setup()
# New small helpers and constant to simplify functions and avoid repeated literals
MAGIC_KINGDOM = "Magic Kingdom"
def _format_coords(coords):
"""
Return (lat, lon) tuple or None for a coords object/sequence.
Accepts objects with .latitude/.longitude or indexable (lat, lon).
"""
if not coords:
return None
lat = getattr(coords, "latitude", None)
lon = getattr(coords, "longitude", None)
if lat is not None and lon is not None:
return (lat, lon)
# Fallback to indexable
try:
return (coords[0], coords[1])
except Exception:
return None
def _print_route_summary(route, indent=" "):
"""Safely print route summary fields if route is present."""
if not route:
return
# Use attributes with fallback to dict keys if needed
formatted_distance = getattr(route, "formatted_distance", None) or route.get(
"formatted_distance", "N/A"
) if isinstance(route, dict) else getattr(route, "formatted_distance", "N/A")
formatted_duration = getattr(route, "formatted_duration", None) or route.get(
"formatted_duration", "N/A"
) if isinstance(route, dict) else getattr(route, "formatted_duration", "N/A")
print(f"{indent}{formatted_distance}, {formatted_duration}")
def demo_florida_theme_park_trip(): def demo_florida_theme_park_trip():
""" """
@@ -26,11 +61,8 @@ def demo_florida_theme_park_trip():
# Define Florida theme parks with addresses # Define Florida theme parks with addresses
florida_parks = [ florida_parks = [
("Magic Kingdom", "Magic Kingdom Dr, Orlando, FL 32830"), (MAGIC_KINGDOM, "Magic Kingdom Dr, Orlando, FL 32830"),
( ("Universal Studios Florida", "6000 Universal Blvd, Orlando, FL 32819"),
"Universal Studios Florida",
"6000 Universal Blvd, Orlando, FL 32819",
),
("SeaWorld Orlando", "7007 Sea World Dr, Orlando, FL 32821"), ("SeaWorld Orlando", "7007 Sea World Dr, Orlando, FL 32821"),
("Busch Gardens Tampa", "10165 McKinley Dr, Tampa, FL 33612"), ("Busch Gardens Tampa", "10165 McKinley Dr, Tampa, FL 33612"),
] ]
@@ -38,18 +70,21 @@ def demo_florida_theme_park_trip():
print("Planning trip for these Florida parks:") print("Planning trip for these Florida parks:")
park_coords = {} park_coords = {}
for name, address in florida_parks: # small helper to geocode and store
def _geocode_and_store(name, address):
print(f"\n📍 Geocoding {name}...") print(f"\n📍 Geocoding {name}...")
coords = service.geocode_address(address) coords = service.geocode_address(address)
if coords: if coords:
latlon = _format_coords(coords)
if latlon:
park_coords[name] = coords park_coords[name] = coords
print( print(f" ✅ Located at {latlon[0]:.4f}, {latlon[1]:.4f}")
f" ✅ Located at { return True
coords.latitude:.4f}, {
coords.longitude:.4f}"
)
else:
print(f" ❌ Could not geocode {address}") print(f" ❌ Could not geocode {address}")
return False
for name, address in florida_parks:
_geocode_and_store(name, address)
if len(park_coords) < 2: if len(park_coords) < 2:
print("❌ Need at least 2 parks to plan a trip") print("❌ Need at least 2 parks to plan a trip")
@@ -65,25 +100,17 @@ def demo_florida_theme_park_trip():
route = service.calculate_route(park_coords[park1], park_coords[park2]) route = service.calculate_route(park_coords[park1], park_coords[park2])
if route: if route:
print(f" {park1} ↔ {park2}") print(f" {park1} ↔ {park2}")
print( _print_route_summary(route, indent=" ")
f" {
route.formatted_distance}, {
route.formatted_duration}"
)
# Find central park for radiating searches # Find central park for radiating searches
print("\n🎢 Parks within 100km of Magic Kingdom:") print(f"\n🎢 Parks within 100km of {MAGIC_KINGDOM}:")
magic_kingdom_coords = park_coords.get("Magic Kingdom") magic_kingdom_coords = park_coords.get(MAGIC_KINGDOM)
if magic_kingdom_coords: if magic_kingdom_coords:
for name, coords in park_coords.items(): for name, coords in park_coords.items():
if name != "Magic Kingdom": if name != MAGIC_KINGDOM:
route = service.calculate_route(magic_kingdom_coords, coords) route = service.calculate_route(magic_kingdom_coords, coords)
if route: if route:
print( _print_route_summary(route, indent=f" {name}: ")
f" {name}: {
route.formatted_distance} ({
route.formatted_duration})"
)
def demo_cross_country_road_trip(): def demo_cross_country_road_trip():
@@ -99,10 +126,7 @@ def demo_cross_country_road_trip():
major_parks = [ major_parks = [
("Disneyland", "1313 Disneyland Dr, Anaheim, CA 92802"), ("Disneyland", "1313 Disneyland Dr, Anaheim, CA 92802"),
("Cedar Point", "1 Cedar Point Dr, Sandusky, OH 44870"), ("Cedar Point", "1 Cedar Point Dr, Sandusky, OH 44870"),
( ("Six Flags Magic Mountain", "26101 Magic Mountain Pkwy, Valencia, CA 91355"),
"Six Flags Magic Mountain",
"26101 Magic Mountain Pkwy, Valencia, CA 91355",
),
("Walt Disney World", "Walt Disney World Resort, Orlando, FL 32830"), ("Walt Disney World", "Walt Disney World Resort, Orlando, FL 32830"),
] ]
@@ -114,7 +138,9 @@ def demo_cross_country_road_trip():
coords = service.geocode_address(address) coords = service.geocode_address(address)
if coords: if coords:
park_coords[name] = coords park_coords[name] = coords
print(f" ✅ {coords.latitude:.4f}, {coords.longitude:.4f}") latlon = _format_coords(coords)
if latlon:
print(f" ✅ {latlon[0]:.4f}, {latlon[1]:.4f}")
if len(park_coords) >= 3: if len(park_coords) >= 3:
# Calculate an optimized route if we have DB parks # Calculate an optimized route if we have DB parks
@@ -136,29 +162,21 @@ def demo_cross_country_road_trip():
to_park = route_order[i + 1] to_park = route_order[i + 1]
if from_park in park_coords and to_park in park_coords: if from_park in park_coords and to_park in park_coords:
route = service.calculate_route( route = service.calculate_route(park_coords[from_park], park_coords[to_park])
park_coords[from_park], park_coords[to_park]
)
if route: if route:
total_distance += route.distance_km total_distance += getattr(route, "distance_km", 0) or route.get("distance_km", 0) if isinstance(route, dict) else getattr(route, "distance_km", 0)
total_time += route.duration_minutes total_time += getattr(route, "duration_minutes", 0) or route.get("duration_minutes", 0) if isinstance(route, dict) else getattr(route, "duration_minutes", 0)
print(f" {i + 1}. {from_park} → {to_park}") print(f" {i + 1}. {from_park} → {to_park}")
print( _print_route_summary(route, indent=" ")
f" {
route.formatted_distance}, {
route.formatted_duration}"
)
print("\n📊 Trip Summary:") print("\n📊 Trip Summary:")
print(f" Total Distance: {total_distance:.1f}km") print(f" Total Distance: {total_distance:.1f}km")
print( hours = total_time // 60
f" Total Driving Time: { mins = total_time % 60
total_time // print(f" Total Driving Time: {hours}h {mins}min")
60}h { # avoid division by zero
total_time % legs = max(1, len(route_order) - 1)
60}min" print(f" Average Distance per Leg: {total_distance / legs:.1f}km")
)
print(f" Average Distance per Leg: {total_distance / 3:.1f}km")
def demo_database_integration(): def demo_database_integration():
@@ -171,9 +189,7 @@ def demo_database_integration():
service = RoadTripService() service = RoadTripService()
# Get parks that have location data # Get parks that have location data
parks_with_location = Park.objects.filter( parks_with_location = Park.objects.filter(location__point__isnull=False).select_related("location")[:5]
location__point__isnull=False
).select_related("location")[:5]
if not parks_with_location: if not parks_with_location:
print("❌ No parks with location data found in database") print("❌ No parks with location data found in database")
@@ -182,9 +198,10 @@ def demo_database_integration():
print(f"Found {len(parks_with_location)} parks with location data:") print(f"Found {len(parks_with_location)} parks with location data:")
for park in parks_with_location: for park in parks_with_location:
coords = park.coordinates coords = getattr(park, "coordinates", None)
if coords: latlon = _format_coords(coords)
print(f" 🎢 {park.name}: {coords[0]:.4f}, {coords[1]:.4f}") if latlon:
print(f" 🎢 {park.name}: {latlon[0]:.4f}, {latlon[1]:.4f}")
# Demonstrate nearby park search # Demonstrate nearby park search
if len(parks_with_location) >= 1: if len(parks_with_location) >= 1:
@@ -196,13 +213,12 @@ def demo_database_integration():
if nearby_parks: if nearby_parks:
print(f" Found {len(nearby_parks)} nearby parks:") print(f" Found {len(nearby_parks)} nearby parks:")
for result in nearby_parks[:3]: # Show top 3 for result in nearby_parks[:3]: # Show top 3
park = result["park"] park = result.get("park") if isinstance(result, dict) else getattr(result, "park", None)
print( # use safe formatted strings
f" 📍 { formatted_distance = result.get("formatted_distance", "N/A") if isinstance(result, dict) else getattr(result, "formatted_distance", "N/A")
park.name}: { formatted_duration = result.get("formatted_duration", "N/A") if isinstance(result, dict) else getattr(result, "formatted_duration", "N/A")
result['formatted_distance']} ({ if park:
result['formatted_duration']})" print(f" 📍 {park.name}: {formatted_distance} ({formatted_duration})")
)
else: else:
print(" No nearby parks found (may need larger radius)") print(" No nearby parks found (may need larger radius)")
@@ -218,17 +234,17 @@ def demo_database_integration():
if trip: if trip:
print("\n✅ Optimized Route:") print("\n✅ Optimized Route:")
print(f" Total Distance: {trip.formatted_total_distance}") print(f" Total Distance: {getattr(trip, 'formatted_total_distance', 'N/A')}")
print(f" Total Duration: {trip.formatted_total_duration}") print(f" Total Duration: {getattr(trip, 'formatted_total_duration', 'N/A')}")
print(" Route:") print(" Route:")
for i, leg in enumerate(trip.legs, 1): for i, leg in enumerate(getattr(trip, "legs", []) or [], 1):
print(f" {i}. {leg.from_park.name} → {leg.to_park.name}") from_park = getattr(leg, "from_park", None)
print( to_park = getattr(leg, "to_park", None)
f" { route = getattr(leg, "route", None)
leg.route.formatted_distance}, { if from_park and to_park:
leg.route.formatted_duration}" print(f" {i}. {from_park.name} → {to_park.name}")
) _print_route_summary(route, indent=" ")
else: else:
print(" ❌ Could not optimize trip route") print(" ❌ Could not optimize trip route")
@@ -243,9 +259,7 @@ def demo_geocoding_fallback():
service = RoadTripService() service = RoadTripService()
# Get parks without location data # Get parks without location data
parks_without_coords = Park.objects.filter( parks_without_coords = Park.objects.filter(location__point__isnull=True).select_related("location")[:3]
location__point__isnull=True
).select_related("location")[:3]
if not parks_without_coords: if not parks_without_coords:
print("✅ All parks already have coordinates") print("✅ All parks already have coordinates")
@@ -256,14 +270,15 @@ def demo_geocoding_fallback():
for park in parks_without_coords: for park in parks_without_coords:
print(f"\n🎢 {park.name}") print(f"\n🎢 {park.name}")
if hasattr(park, "location") and park.location: location = getattr(park, "location", None)
location = park.location if location:
# use getattr to avoid attribute errors
address_parts = [ address_parts = [
park.name, getattr(park, "name", None),
location.street_address, getattr(location, "street_address", None),
location.city, getattr(location, "city", None),
location.state, getattr(location, "state", None),
location.country, getattr(location, "country", None),
] ]
address = ", ".join(part for part in address_parts if part) address = ", ".join(part for part in address_parts if part)
print(f" Address: {address}") print(f" Address: {address}")
@@ -271,8 +286,12 @@ def demo_geocoding_fallback():
# Try to geocode # Try to geocode
success = service.geocode_park_if_needed(park) success = service.geocode_park_if_needed(park)
if success: if success:
coords = park.coordinates coords = getattr(park, "coordinates", None)
print(f" ✅ Geocoded to: {coords[0]:.4f}, {coords[1]:.4f}") latlon = _format_coords(coords)
if latlon:
print(f" ✅ Geocoded to: {latlon[0]:.4f}, {latlon[1]:.4f}")
else:
print(" ✅ Geocoded but coordinates unavailable")
else: else:
print(" ❌ Geocoding failed") print(" ❌ Geocoding failed")
else: else:
@@ -302,7 +321,11 @@ def demo_cache_performance():
first_duration = time.time() - start_time first_duration = time.time() - start_time
if coords1: if coords1:
print(f" ✅ Result: {coords1.latitude:.4f}, {coords1.longitude:.4f}") latlon = _format_coords(coords1)
if latlon:
print(f" ✅ Result: {latlon[0]:.4f}, {latlon[1]:.4f}")
else:
print(" ✅ Result obtained")
print(f" ⏱️ Duration: {first_duration:.2f} seconds") print(f" ⏱️ Duration: {first_duration:.2f} seconds")
# Second request (cache hit) # Second request (cache hit)
@@ -312,17 +335,22 @@ def demo_cache_performance():
second_duration = time.time() - start_time second_duration = time.time() - start_time
if coords2: if coords2:
print(f" ✅ Result: {coords2.latitude:.4f}, {coords2.longitude:.4f}") latlon2 = _format_coords(coords2)
if latlon2:
print(f" ✅ Result: {latlon2[0]:.4f}, {latlon2[1]:.4f}")
else:
print(" ✅ Result obtained")
print(f" ⏱️ Duration: {second_duration:.2f} seconds") print(f" ⏱️ Duration: {second_duration:.2f} seconds")
if first_duration > second_duration: if first_duration > second_duration and second_duration > 0:
speedup = first_duration / second_duration speedup = first_duration / second_duration
print(f" 🚀 Cache speedup: {speedup:.1f}x faster") print(f" 🚀 Cache speedup: {speedup:.1f}x faster")
if ( # Compare coordinates if both present
coords1.latitude == coords2.latitude if coords1 and coords2:
and coords1.longitude == coords2.longitude latlon1 = _format_coords(coords1)
): latlon2 = _format_coords(coords2)
if latlon1 and latlon2 and latlon1 == latlon2:
print(" ✅ Results identical (cache working)") print(" ✅ Results identical (cache working)")

26
tests/test_location_models.py
View File

@@ -2,8 +2,8 @@
""" """
Basic test script to verify RideLocation and CompanyHeadquarters models work correctly. Basic test script to verify RideLocation and CompanyHeadquarters models work correctly.
""" """
from rides.models import Ride, RideLocation from apps.rides.models import Ride, RideLocation
from parks.models import Company, CompanyHeadquarters from apps.parks.models import Company, CompanyHeadquarters
import os import os
import sys import sys
import django import django
@@ -23,11 +23,11 @@ def test_company_headquarters():
print("⚠️ No existing companies found, skipping CompanyHeadquarters test") print("⚠️ No existing companies found, skipping CompanyHeadquarters test")
return None, None return None, None
# Check if headquarters already exist # Check if headquarters already exist (use queryset lookup to avoid relying on a reverse attribute name)
try: headquarters = CompanyHeadquarters.objects.filter(company=existing_company).first()
headquarters = existing_company.headquarters if headquarters:
print(f"✓ Found existing headquarters: {headquarters}") print(f"✓ Found existing headquarters: {headquarters}")
except CompanyHeadquarters.DoesNotExist: else:
# Create headquarters for existing company # Create headquarters for existing company
headquarters = CompanyHeadquarters.objects.create( headquarters = CompanyHeadquarters.objects.create(
company=existing_company, company=existing_company,
@@ -53,7 +53,13 @@ def test_ride_location():
# First, we need a ride - let's check if any exist # First, we need a ride - let's check if any exist
if Ride.objects.exists(): if Ride.objects.exists():
ride = Ride.objects.first() ride = Ride.objects.first()
print(f"✓ Using existing ride: {ride.name}") # Safely access the ride's name in case static analysis or runtime sees None/no attribute.
ride_name = getattr(ride, "name", None) if ride is not None else None
if ride_name:
print(f"✓ Using existing ride: {ride_name}")
else:
# Fall back to repr of the ride object to avoid AttributeError
print(f"✓ Using existing ride: {ride!r}")
else: else:
print("! No rides found in database - skipping RideLocation test") print("! No rides found in database - skipping RideLocation test")
return None, None return None, None
@@ -93,9 +99,9 @@ def cleanup_test_data(company=None, headquarters=None, ride_location=None):
headquarters.delete() headquarters.delete()
print("✓ Deleted test headquarters") print("✓ Deleted test headquarters")
if company: # Do not delete an existing company record discovered in the database.
company.delete() # Tests should avoid removing production/existing data. If a test created a Company
print("✓ Deleted test company") # instance explicitly, add logic to delete it here (not implemented by default).
def main(): def main():

12
tests/test_manual_trigger.py
View File

@@ -46,7 +46,7 @@ def test_trigger_endpoint(token):
"Content-Type": "application/json" "Content-Type": "application/json"
} }
print(f"\n🚀 Testing manual trigger endpoint...") print("\n🚀 Testing manual trigger endpoint...")
print(f"URL: {trigger_url}") print(f"URL: {trigger_url}")
response = requests.post(trigger_url, headers=headers) response = requests.post(trigger_url, headers=headers)
@@ -72,7 +72,7 @@ def test_trigger_endpoint(token):
def test_trending_endpoints(): def test_trending_endpoints():
"""Test the trending content endpoints to see the results.""" """Test the trending content endpoints to see the results."""
print(f"\n📊 Testing trending content endpoints...") print("\n📊 Testing trending content endpoints...")
# Test trending content endpoint # Test trending content endpoint
trending_url = f"{BASE_URL}/api/v1/trending/content/" trending_url = f"{BASE_URL}/api/v1/trending/content/"
@@ -109,7 +109,7 @@ def test_trending_endpoints():
# Show the newly_opened structure to verify our changes # Show the newly_opened structure to verify our changes
if data.get('newly_opened'): if data.get('newly_opened'):
print(f"\n🎢 First newly opened item structure:") print("\n🎢 First newly opened item structure:")
first_item = data['newly_opened'][0] first_item = data['newly_opened'][0]
print(f" Name: {first_item.get('name')}") print(f" Name: {first_item.get('name')}")
# Should be park name, not location # Should be park name, not location
@@ -124,12 +124,12 @@ def test_trending_endpoints():
print( print(
f" ❌ ERROR: 'location' field still present: {first_item['location']}") f" ❌ ERROR: 'location' field still present: {first_item['location']}")
else: else:
print(f" ✅ SUCCESS: 'location' field removed as requested") print(" ✅ SUCCESS: 'location' field removed as requested")
def test_unauthorized_access(): def test_unauthorized_access():
"""Test that non-admin users cannot access the trigger endpoint.""" """Test that non-admin users cannot access the trigger endpoint."""
print(f"\n🔒 Testing unauthorized access...") print("\n🔒 Testing unauthorized access...")
trigger_url = f"{BASE_URL}/api/v1/trending/calculate/" trigger_url = f"{BASE_URL}/api/v1/trending/calculate/"
@@ -169,7 +169,7 @@ def main():
trigger_result = test_trigger_endpoint(token) trigger_result = test_trigger_endpoint(token)
if trigger_result: if trigger_result:
print(f"\n⏳ Waiting 10 seconds for tasks to process...") print("\n⏳ Waiting 10 seconds for tasks to process...")
time.sleep(10) time.sleep(10)
# Test the trending endpoints to see results # Test the trending endpoints to see results

2
tests/test_park_location.py
View File

@@ -2,7 +2,7 @@
""" """
Test script for ParkLocation model functionality Test script for ParkLocation model functionality
""" """
from parks.models import Park, ParkLocation, Company from apps.parks.models import Park, ParkLocation, Company
import os import os
import django import django

118
tests/test_roadtrip_service.py
View File

@@ -9,14 +9,21 @@ This script tests all functionality of the OSM Road Trip Service including:
- Integration with existing Park models - Integration with existing Park models
""" """
from typing import cast
from apps.parks.services import RoadTripService
from apps.parks.services.roadtrip import Coordinates
from apps.parks.models import Park
from django.core.cache import cache from django.core.cache import cache
from parks.models import Park
from parks.services.roadtrip import Coordinates
from parks.services import RoadTripService
import os import os
import sys
import django import django
# Setup Django # Ensure project root is on sys.path so imports like `parks.models` resolve.
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if PROJECT_ROOT not in sys.path:
sys.path.insert(0, PROJECT_ROOT)
# Setup Django before importing project modules that depend on settings.
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "thrillwiki.settings") os.environ.setdefault("DJANGO_SETTINGS_MODULE", "thrillwiki.settings")
django.setup() django.setup()
@@ -40,16 +47,13 @@ def test_geocoding():
print(f"\nGeocoding: {address}") print(f"\nGeocoding: {address}")
coords = service.geocode_address(address) coords = service.geocode_address(address)
if coords: if coords:
print( # fixed: single-line f-string formatting
f" ✅ Success: { print(f" ✅ Success: {coords.latitude:.6f}, {coords.longitude:.6f}")
coords.latitude:.6f}, {
coords.longitude:.6f}"
)
else: else:
print(f" ❌ Failed") print(" ❌ Failed")
# Test cache functionality # Test cache functionality
print(f"\nTesting cache...") print("\nTesting cache...")
coords1 = service.geocode_address("Cedar Point, Sandusky, Ohio") coords1 = service.geocode_address("Cedar Point, Sandusky, Ohio")
coords2 = service.geocode_address("Cedar Point, Sandusky, Ohio") coords2 = service.geocode_address("Cedar Point, Sandusky, Ohio")
if coords1 and coords2: if coords1 and coords2:
@@ -66,30 +70,30 @@ def test_route_calculation():
cedar_point = Coordinates(41.4793, -82.6833) cedar_point = Coordinates(41.4793, -82.6833)
magic_kingdom = Coordinates(28.4177, -81.5812) magic_kingdom = Coordinates(28.4177, -81.5812)
print(f"Calculating route from Cedar Point to Magic Kingdom...") print("Calculating route from Cedar Point to Magic Kingdom...")
route = service.calculate_route(cedar_point, magic_kingdom) route = service.calculate_route(cedar_point, magic_kingdom)
if route: if route:
print(f" ✅ Success:") print(" ✅ Success:")
print(f" Distance: {route.formatted_distance}") print(f" Distance: {route.formatted_distance}")
print(f" Duration: {route.formatted_duration}") print(f" Duration: {route.formatted_duration}")
print(f" Geometry: {'Yes' if route.geometry else 'No'}") print(f" Geometry: {'Yes' if route.geometry else 'No'}")
else: else:
print(f" ❌ Failed") print(" ❌ Failed")
# Test short distance (should use OSRM) # Test short distance (should use OSRM)
disneyland = Coordinates(33.8121, -117.9190) disneyland = Coordinates(33.8121, -117.9190)
knotts = Coordinates(33.8442, -118.0000) knotts = Coordinates(33.8442, -118.0000)
print(f"\nCalculating route from Disneyland to Knott's Berry Farm...") print("\nCalculating route from Disneyland to Knott's Berry Farm...")
route = service.calculate_route(disneyland, knotts) route = service.calculate_route(disneyland, knotts)
if route: if route:
print(f" ✅ Success:") print(" ✅ Success:")
print(f" Distance: {route.formatted_distance}") print(f" Distance: {route.formatted_distance}")
print(f" Duration: {route.formatted_duration}") print(f" Duration: {route.formatted_duration}")
else: else:
print(f" ❌ Failed") print(" ❌ Failed")
def test_park_integration(): def test_park_integration():
@@ -108,24 +112,25 @@ def test_park_integration():
print(f"Found {len(parks)} parks to test with:") print(f"Found {len(parks)} parks to test with:")
for park in parks: for park in parks:
print(f" - {park.name}") print(f" - {park.name}")
if hasattr(park, "location") and park.location: # Use getattr to safely access the optional related attribute and avoid static type warnings.
coords = park.coordinates location = getattr(park, "location", None)
if location:
coords = getattr(park, "coordinates", None)
if coords: if coords:
print(f" 📍 {coords[0]:.4f}, {coords[1]:.4f}") print(f" 📍 {coords[0]:.4f}, {coords[1]:.4f}")
else: else:
print(f" 📍 No coordinates, will try to geocode...") print(" 📍 No coordinates, will try to geocode...")
success = service.geocode_park_if_needed(park) success = service.geocode_park_if_needed(park)
if success: if success:
coords = park.coordinates coords = getattr(park, "coordinates", None)
print( if coords:
f" ✅ Geocoded to: { print(f" ✅ Geocoded to: {coords[0]:.4f}, {coords[1]:.4f}")
coords[0]:.4f}, {
coords[1]:.4f}"
)
else: else:
print(f" ❌ Geocoding failed") print(" ❌ Geocoding succeeded but coordinates still missing")
else: else:
print(f" ❌ No location data") print(" ❌ Geocoding failed")
else:
print(" ❌ No location data")
def test_nearby_parks(): def test_nearby_parks():
@@ -153,13 +158,9 @@ def test_nearby_parks():
for result in nearby_parks[:5]: # Show first 5 for result in nearby_parks[:5]: # Show first 5
park = result["park"] park = result["park"]
print( print(
f" { f" {park.name}: {result['formatted_distance']}, {result['formatted_duration']}")
park.name}: {
result['formatted_distance']}, {
result['formatted_duration']}"
)
else: else:
print(f" ❌ No nearby parks found") print(" ❌ No nearby parks found")
def test_route_park_discovery(): def test_route_park_discovery():
@@ -180,11 +181,7 @@ def test_route_park_discovery():
start_park = parks_with_location[0] start_park = parks_with_location[0]
end_park = parks_with_location[1] end_park = parks_with_location[1]
print( print(f"Finding parks along route from {start_park.name} to {end_park.name}...")
f"Finding parks along route from {
start_park.name} to {
end_park.name}..."
)
parks_along_route = service.find_parks_along_route( parks_along_route = service.find_parks_along_route(
start_park, end_park, max_detour_km=100 start_park, end_park, max_detour_km=100
@@ -195,7 +192,7 @@ def test_route_park_discovery():
for park in parks_along_route[:3]: # Show first 3 for park in parks_along_route[:3]: # Show first 3
print(f" - {park.name}") print(f" - {park.name}")
else: else:
print(f" ❌ No parks found along route") print(" ❌ No parks found along route")
def test_multi_park_trip(): def test_multi_park_trip():
@@ -221,19 +218,16 @@ def test_multi_park_trip():
trip = service.create_multi_park_trip(parks_list) trip = service.create_multi_park_trip(parks_list)
if trip: if trip:
print(f" ✅ Trip planned successfully:") print(" ✅ Trip planned successfully:")
print(f" Total Distance: {trip.formatted_total_distance}") print(f" Total Distance: {trip.formatted_total_distance}")
print(f" Total Duration: {trip.formatted_total_duration}") print(f" Total Duration: {trip.formatted_total_duration}")
print(f" Route:") print(" Route:")
for i, leg in enumerate(trip.legs, 1): for i, leg in enumerate(trip.legs, 1):
print(f" {i}. {leg.from_park.name} → {leg.to_park.name}") print(f" {i}. {leg.from_park.name} → {leg.to_park.name}")
print( print(
f" { f" {leg.route.formatted_distance}, {leg.route.formatted_duration}")
leg.route.formatted_distance}, {
leg.route.formatted_duration}"
)
else: else:
print(f" ❌ Trip planning failed") print(" ❌ Trip planning failed")
def test_error_handling(): def test_error_handling():
@@ -249,28 +243,28 @@ def test_error_handling():
route = service.calculate_route(invalid_coords, valid_coords) route = service.calculate_route(invalid_coords, valid_coords)
if route: if route:
print( print(f" ⚠️ Got route with invalid coords: {route.formatted_distance}")
f" ⚠️ Got route with invalid coords: {
route.formatted_distance}"
)
else: else:
print(f" ✅ Correctly handled invalid coordinates") print(" ✅ Correctly handled invalid coordinates")
# Test with empty address # Test with empty address
print("Testing empty address geocoding...") print("Testing empty address geocoding...")
coords = service.geocode_address("") coords = service.geocode_address("")
if coords: if coords:
print(f" ⚠️ Got coordinates for empty address") print(" ⚠️ Got coordinates for empty address")
else: else:
print(f" ✅ Correctly handled empty address") print(" ✅ Correctly handled empty address")
# Test with None values # Test with None values
print("Testing None coordinates...") print("Testing None coordinates...")
route = service.calculate_route(None, valid_coords) # cast(None, Coordinates) is used only to satisfy static typing checks
# while keeping the runtime intent of passing None to the service.
route = service.calculate_route(cast(Coordinates, None), valid_coords)
if route: if route:
print(f" ⚠️ Got route with None coordinates") print(" ⚠️ Got route with None coordinates")
else: else:
print(f" ✅ Correctly handled None coordinates") print(" ✅ Correctly handled None coordinates")
def test_rate_limiting(): def test_rate_limiting():
@@ -294,19 +288,15 @@ def test_rate_limiting():
for address in addresses: for address in addresses:
coords = service.geocode_address(address) coords = service.geocode_address(address)
if coords: if coords:
print( print(f" ✅ {address}: {coords.latitude:.4f}, {coords.longitude:.4f}")
f" ✅ {address}: {
coords.latitude:.4f}, {
coords.longitude:.4f}"
)
elapsed = time.time() - start_time elapsed = time.time() - start_time
print(f" Total time for 3 requests: {elapsed:.2f} seconds") print(f" Total time for 3 requests: {elapsed:.2f} seconds")
if elapsed >= 2.0: # Should take at least 2 seconds with 1 req/sec limit if elapsed >= 2.0: # Should take at least 2 seconds with 1 req/sec limit
print(f" ✅ Rate limiting appears to be working") print(" ✅ Rate limiting appears to be working")
else: else:
print(f" ⚠️ Requests may have been cached or rate limiting not working") print(" ⚠️ Requests may have been cached or rate limiting not working")
def main(): def main():

16
tests/test_unified_map_service.py
View File

@@ -4,16 +4,24 @@ Test script for the unified map service.
This script tests the map service with real location data. This script tests the map service with real location data.
""" """
from core.services.data_structures import GeoBounds, MapFilters, LocationType
from core.services.map_service import unified_map_service
import os import os
import sys import sys
import django import django
# Setup Django environment # Ensure project root is on sys.path so imports like `core.services.*` resolve.
# This inserts the parent directory of the tests folder (project root).
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
if PROJECT_ROOT not in sys.path:
sys.path.insert(0, PROJECT_ROOT)
# Setup Django environment before importing app modules that depend on settings.
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "thrillwiki.settings") os.environ.setdefault("DJANGO_SETTINGS_MODULE", "thrillwiki.settings")
django.setup() django.setup()
# Now import project modules
from apps.core.services.data_structures import GeoBounds, MapFilters, LocationType # noqa: E402
from apps.core.services.map_service import unified_map_service # noqa: E402
def test_basic_map_service(): def test_basic_map_service():
"""Test basic map service functionality.""" """Test basic map service functionality."""
@@ -215,7 +223,7 @@ def test_performance():
print(f" Max time: {max(times):.2f}ms") print(f" Max time: {max(times):.2f}ms")
# Test cache performance # Test cache performance
print(f"\n Testing cache performance:") print("\n Testing cache performance:")
start = time.time() start = time.time()
response1 = unified_map_service.get_map_data(zoom_level=10, use_cache=True) response1 = unified_map_service.get_map_data(zoom_level=10, use_cache=True)
time1 = time.time() - start time1 = time.time() - start