refactor(tests): TDD rewrite of all unit tests with spec documentation
Complete rewrite of unit test suite using TDD methodology: Planning Engine Tests: - GameDAGRouterTests: Beam search, anchor games, transitions - ItineraryBuilderTests: Stop connection, validators, EV enrichment - RouteFiltersTests: Region, time window, scoring filters - ScenarioA/B/C/D PlannerTests: All planning scenarios - TravelEstimatorTests: Distance, duration, travel days - TripPlanningEngineTests: Orchestration, caching, preferences Domain Model Tests: - AchievementDefinitionsTests, AnySportTests, DivisionTests - GameTests, ProgressTests, RegionTests, StadiumTests - TeamTests, TravelSegmentTests, TripTests, TripPollTests - TripPreferencesTests, TripStopTests, SportTests Service Tests: - FreeScoreAPITests, RouteDescriptionGeneratorTests - SuggestedTripsGeneratorTests Export Tests: - ShareableContentTests (card types, themes, dimensions) Bug fixes discovered through TDD: - ShareCardDimensions: mapSnapshotSize exceeded available width (960x480) - ScenarioBPlanner: Added anchor game validation filter All tests include: - Specification tests (expected behavior) - Invariant tests (properties that must always hold) - Edge case tests (boundary conditions) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Trey t
@@ -2,495 +2,340 @@
|
||||
// ScenarioBPlannerTests.swift
|
||||
// SportsTimeTests
|
||||
//
|
||||
// Phase 5: ScenarioBPlanner Tests
|
||||
// Scenario B: User selects specific games (must-see), planner builds route.
|
||||
// TDD specification tests for ScenarioBPlanner.
|
||||
//
|
||||
|
||||
import Testing
|
||||
import CoreLocation
|
||||
@testable import SportsTime
|
||||
|
||||
@Suite("ScenarioBPlanner Tests", .serialized)
|
||||
@Suite("ScenarioBPlanner")
|
||||
struct ScenarioBPlannerTests {
|
||||
|
||||
// MARK: - Test Fixtures
|
||||
// MARK: - Test Data
|
||||
|
||||
private let calendar = Calendar.current
|
||||
private let planner = ScenarioBPlanner()
|
||||
|
||||
/// Creates a date with specific year/month/day/hour
|
||||
private func makeDate(year: Int = 2026, month: Int = 6, day: Int, hour: Int = 19) -> Date {
|
||||
var components = DateComponents()
|
||||
components.year = year
|
||||
components.month = month
|
||||
components.day = day
|
||||
components.hour = hour
|
||||
components.minute = 0
|
||||
return calendar.date(from: components)!
|
||||
private let nycCoord = CLLocationCoordinate2D(latitude: 40.7580, longitude: -73.9855)
|
||||
private let bostonCoord = CLLocationCoordinate2D(latitude: 42.3467, longitude: -71.0972)
|
||||
private let phillyCoord = CLLocationCoordinate2D(latitude: 39.9526, longitude: -75.1652)
|
||||
|
||||
// MARK: - Specification Tests: No Selected Games
|
||||
|
||||
@Test("plan: no selected games returns failure")
|
||||
func plan_noSelectedGames_returnsFailure() {
|
||||
let startDate = Date()
|
||||
let endDate = startDate.addingTimeInterval(86400 * 7)
|
||||
|
||||
let prefs = TripPreferences(
|
||||
planningMode: .gameFirst,
|
||||
sports: [.mlb],
|
||||
mustSeeGameIds: [], // No selected games
|
||||
startDate: startDate,
|
||||
endDate: endDate,
|
||||
leisureLevel: .moderate,
|
||||
lodgingType: .hotel,
|
||||
numberOfDrivers: 1
|
||||
)
|
||||
|
||||
let request = PlanningRequest(
|
||||
preferences: prefs,
|
||||
availableGames: [],
|
||||
teams: [:],
|
||||
stadiums: [:]
|
||||
)
|
||||
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
guard case .failure(let failure) = result else {
|
||||
Issue.record("Expected failure when no games selected")
|
||||
return
|
||||
}
|
||||
#expect(failure.reason == .noValidRoutes)
|
||||
}
|
||||
|
||||
/// Creates a stadium at a known location
|
||||
// MARK: - Specification Tests: Anchor Games
|
||||
|
||||
@Test("plan: single selected game returns success with that game")
|
||||
func plan_singleSelectedGame_returnsSuccess() {
|
||||
let startDate = Date()
|
||||
let endDate = startDate.addingTimeInterval(86400 * 7)
|
||||
let gameDate = startDate.addingTimeInterval(86400 * 2)
|
||||
|
||||
let stadium = makeStadium(id: "stadium1", city: "New York", coordinate: nycCoord)
|
||||
let game = makeGame(id: "game1", stadiumId: "stadium1", dateTime: gameDate)
|
||||
|
||||
let prefs = TripPreferences(
|
||||
planningMode: .gameFirst,
|
||||
sports: [.mlb],
|
||||
mustSeeGameIds: ["game1"],
|
||||
startDate: startDate,
|
||||
endDate: endDate,
|
||||
leisureLevel: .moderate,
|
||||
lodgingType: .hotel,
|
||||
numberOfDrivers: 1
|
||||
)
|
||||
|
||||
let request = PlanningRequest(
|
||||
preferences: prefs,
|
||||
availableGames: [game],
|
||||
teams: [:],
|
||||
stadiums: ["stadium1": stadium]
|
||||
)
|
||||
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
guard case .success(let options) = result else {
|
||||
Issue.record("Expected success with single selected game")
|
||||
return
|
||||
}
|
||||
|
||||
#expect(!options.isEmpty)
|
||||
let allGameIds = options.flatMap { $0.stops.flatMap { $0.games } }
|
||||
#expect(allGameIds.contains("game1"), "Selected game must be in result")
|
||||
}
|
||||
|
||||
@Test("plan: all selected games appear in every route")
|
||||
func plan_allSelectedGamesAppearInRoutes() {
|
||||
let startDate = Date()
|
||||
let endDate = startDate.addingTimeInterval(86400 * 10)
|
||||
|
||||
let nycStadium = makeStadium(id: "nyc", city: "New York", coordinate: nycCoord)
|
||||
let bostonStadium = makeStadium(id: "boston", city: "Boston", coordinate: bostonCoord)
|
||||
let phillyStadium = makeStadium(id: "philly", city: "Philadelphia", coordinate: phillyCoord)
|
||||
|
||||
let nycGame = makeGame(id: "nyc-game", stadiumId: "nyc", dateTime: startDate.addingTimeInterval(86400))
|
||||
let bostonGame = makeGame(id: "boston-game", stadiumId: "boston", dateTime: startDate.addingTimeInterval(86400 * 3))
|
||||
let phillyGame = makeGame(id: "philly-game", stadiumId: "philly", dateTime: startDate.addingTimeInterval(86400 * 5))
|
||||
|
||||
// Select NYC and Boston games as anchors
|
||||
let prefs = TripPreferences(
|
||||
planningMode: .gameFirst,
|
||||
sports: [.mlb],
|
||||
mustSeeGameIds: ["nyc-game", "boston-game"],
|
||||
startDate: startDate,
|
||||
endDate: endDate,
|
||||
leisureLevel: .moderate,
|
||||
lodgingType: .hotel,
|
||||
numberOfDrivers: 2
|
||||
)
|
||||
|
||||
let request = PlanningRequest(
|
||||
preferences: prefs,
|
||||
availableGames: [nycGame, bostonGame, phillyGame],
|
||||
teams: [:],
|
||||
stadiums: ["nyc": nycStadium, "boston": bostonStadium, "philly": phillyStadium]
|
||||
)
|
||||
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
if case .success(let options) = result {
|
||||
for option in options {
|
||||
let gameIds = option.stops.flatMap { $0.games }
|
||||
#expect(gameIds.contains("nyc-game"), "Every route must contain selected NYC game")
|
||||
#expect(gameIds.contains("boston-game"), "Every route must contain selected Boston game")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Specification Tests: Sliding Window
|
||||
|
||||
@Test("plan: gameFirst mode uses sliding window")
|
||||
func plan_gameFirstMode_usesSlidingWindow() {
|
||||
let stadium = makeStadium(id: "stadium1", city: "New York", coordinate: nycCoord)
|
||||
|
||||
// Game on a specific date
|
||||
let gameDate = Date().addingTimeInterval(86400 * 5)
|
||||
let game = makeGame(id: "game1", stadiumId: "stadium1", dateTime: gameDate)
|
||||
|
||||
let prefs = TripPreferences(
|
||||
planningMode: .gameFirst,
|
||||
sports: [.mlb],
|
||||
mustSeeGameIds: ["game1"],
|
||||
startDate: Date(),
|
||||
endDate: Date().addingTimeInterval(86400 * 30),
|
||||
leisureLevel: .moderate,
|
||||
lodgingType: .hotel,
|
||||
numberOfDrivers: 1,
|
||||
gameFirstTripDuration: 7 // 7-day trip
|
||||
)
|
||||
|
||||
let request = PlanningRequest(
|
||||
preferences: prefs,
|
||||
availableGames: [game],
|
||||
teams: [:],
|
||||
stadiums: ["stadium1": stadium]
|
||||
)
|
||||
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// Should succeed even without explicit dates because of sliding window
|
||||
if case .success(let options) = result {
|
||||
#expect(!options.isEmpty)
|
||||
}
|
||||
// May also fail if no valid date ranges, which is acceptable
|
||||
}
|
||||
|
||||
// MARK: - Specification Tests: Arrival Time Validation
|
||||
|
||||
@Test("plan: uses arrivalBeforeGameStart validator")
|
||||
func plan_usesArrivalValidator() {
|
||||
// This test verifies that ScenarioB uses arrival time validation
|
||||
// by creating a scenario where travel time makes arrival impossible
|
||||
|
||||
let now = Date()
|
||||
let game1Date = now.addingTimeInterval(86400) // Tomorrow
|
||||
let game2Date = now.addingTimeInterval(86400 + 3600) // Tomorrow + 1 hour (impossible to drive from coast to coast)
|
||||
|
||||
// NYC to LA is ~40 hours of driving
|
||||
let nycStadium = makeStadium(id: "nyc", city: "New York", coordinate: nycCoord)
|
||||
let laStadium = makeStadium(id: "la", city: "Los Angeles", coordinate: CLLocationCoordinate2D(latitude: 34.0430, longitude: -118.2673))
|
||||
|
||||
let nycGame = makeGame(id: "nyc-game", stadiumId: "nyc", dateTime: game1Date)
|
||||
let laGame = makeGame(id: "la-game", stadiumId: "la", dateTime: game2Date)
|
||||
|
||||
let prefs = TripPreferences(
|
||||
planningMode: .gameFirst,
|
||||
sports: [.mlb],
|
||||
mustSeeGameIds: ["nyc-game", "la-game"],
|
||||
startDate: now,
|
||||
endDate: now.addingTimeInterval(86400 * 7),
|
||||
leisureLevel: .moderate,
|
||||
lodgingType: .hotel,
|
||||
numberOfDrivers: 1
|
||||
)
|
||||
|
||||
let request = PlanningRequest(
|
||||
preferences: prefs,
|
||||
availableGames: [nycGame, laGame],
|
||||
teams: [:],
|
||||
stadiums: ["nyc": nycStadium, "la": laStadium]
|
||||
)
|
||||
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// Should fail because it's impossible to arrive in LA 1 hour after leaving NYC
|
||||
guard case .failure = result else {
|
||||
Issue.record("Expected failure when travel time makes arrival impossible")
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Invariant Tests
|
||||
|
||||
@Test("Invariant: selected games cannot be dropped")
|
||||
func invariant_selectedGamesCannotBeDropped() {
|
||||
let startDate = Date()
|
||||
let endDate = startDate.addingTimeInterval(86400 * 14)
|
||||
|
||||
let nycStadium = makeStadium(id: "nyc", city: "New York", coordinate: nycCoord)
|
||||
let bostonStadium = makeStadium(id: "boston", city: "Boston", coordinate: bostonCoord)
|
||||
|
||||
let nycGame = makeGame(id: "nyc-anchor", stadiumId: "nyc", dateTime: startDate.addingTimeInterval(86400 * 2))
|
||||
let bostonGame = makeGame(id: "boston-anchor", stadiumId: "boston", dateTime: startDate.addingTimeInterval(86400 * 5))
|
||||
|
||||
let prefs = TripPreferences(
|
||||
planningMode: .gameFirst,
|
||||
sports: [.mlb],
|
||||
mustSeeGameIds: ["nyc-anchor", "boston-anchor"],
|
||||
startDate: startDate,
|
||||
endDate: endDate,
|
||||
leisureLevel: .moderate,
|
||||
lodgingType: .hotel,
|
||||
numberOfDrivers: 2
|
||||
)
|
||||
|
||||
let request = PlanningRequest(
|
||||
preferences: prefs,
|
||||
availableGames: [nycGame, bostonGame],
|
||||
teams: [:],
|
||||
stadiums: ["nyc": nycStadium, "boston": bostonStadium]
|
||||
)
|
||||
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
if case .success(let options) = result {
|
||||
for option in options {
|
||||
let gameIds = Set(option.stops.flatMap { $0.games })
|
||||
#expect(gameIds.contains("nyc-anchor"), "Anchor game cannot be dropped: nyc-anchor")
|
||||
#expect(gameIds.contains("boston-anchor"), "Anchor game cannot be dropped: boston-anchor")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Property Tests
|
||||
|
||||
@Test("Property: success with selected games includes all anchors")
|
||||
func property_successIncludesAllAnchors() {
|
||||
let startDate = Date()
|
||||
let endDate = startDate.addingTimeInterval(86400 * 7)
|
||||
let gameDate = startDate.addingTimeInterval(86400 * 2)
|
||||
|
||||
let stadium = makeStadium(id: "stadium1", city: "New York", coordinate: nycCoord)
|
||||
let game = makeGame(id: "anchor1", stadiumId: "stadium1", dateTime: gameDate)
|
||||
|
||||
let prefs = TripPreferences(
|
||||
planningMode: .gameFirst,
|
||||
sports: [.mlb],
|
||||
mustSeeGameIds: ["anchor1"],
|
||||
startDate: startDate,
|
||||
endDate: endDate,
|
||||
leisureLevel: .moderate,
|
||||
lodgingType: .hotel,
|
||||
numberOfDrivers: 1
|
||||
)
|
||||
|
||||
let request = PlanningRequest(
|
||||
preferences: prefs,
|
||||
availableGames: [game],
|
||||
teams: [:],
|
||||
stadiums: ["stadium1": stadium]
|
||||
)
|
||||
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
if case .success(let options) = result {
|
||||
#expect(!options.isEmpty, "Success must have options")
|
||||
for option in options {
|
||||
let allGames = option.stops.flatMap { $0.games }
|
||||
#expect(allGames.contains("anchor1"), "Every option must include anchor")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Helper Methods
|
||||
|
||||
private func makeStadium(
|
||||
id: String = "stadium_test_\(UUID().uuidString)",
|
||||
id: String,
|
||||
city: String,
|
||||
lat: Double,
|
||||
lon: Double,
|
||||
sport: Sport = .mlb
|
||||
coordinate: CLLocationCoordinate2D
|
||||
) -> Stadium {
|
||||
Stadium(
|
||||
id: id,
|
||||
name: "\(city) Stadium",
|
||||
city: city,
|
||||
state: "ST",
|
||||
latitude: lat,
|
||||
longitude: lon,
|
||||
state: "XX",
|
||||
latitude: coordinate.latitude,
|
||||
longitude: coordinate.longitude,
|
||||
capacity: 40000,
|
||||
sport: sport
|
||||
sport: .mlb
|
||||
)
|
||||
}
|
||||
|
||||
/// Creates a game at a stadium
|
||||
private func makeGame(
|
||||
id: String = "game_test_\(UUID().uuidString)",
|
||||
id: String,
|
||||
stadiumId: String,
|
||||
homeTeamId: String = "team_test_\(UUID().uuidString)",
|
||||
awayTeamId: String = "team_test_\(UUID().uuidString)",
|
||||
dateTime: Date,
|
||||
sport: Sport = .mlb
|
||||
dateTime: Date
|
||||
) -> Game {
|
||||
Game(
|
||||
id: id,
|
||||
homeTeamId: homeTeamId,
|
||||
awayTeamId: awayTeamId,
|
||||
homeTeamId: "team1",
|
||||
awayTeamId: "team2",
|
||||
stadiumId: stadiumId,
|
||||
dateTime: dateTime,
|
||||
sport: sport,
|
||||
season: "2026"
|
||||
sport: .mlb,
|
||||
season: "2026",
|
||||
isPlayoff: false
|
||||
)
|
||||
}
|
||||
|
||||
/// Creates a PlanningRequest for Scenario B (must-see games mode)
|
||||
private func makePlanningRequest(
|
||||
startDate: Date,
|
||||
endDate: Date,
|
||||
allGames: [Game],
|
||||
mustSeeGameIds: Set<String>,
|
||||
stadiums: [String: Stadium],
|
||||
teams: [String: Team] = [:],
|
||||
allowRepeatCities: Bool = true,
|
||||
numberOfDrivers: Int = 1,
|
||||
maxDrivingHoursPerDriver: Double = 8.0
|
||||
) -> PlanningRequest {
|
||||
let preferences = TripPreferences(
|
||||
planningMode: .gameFirst,
|
||||
sports: [.mlb],
|
||||
mustSeeGameIds: mustSeeGameIds,
|
||||
startDate: startDate,
|
||||
endDate: endDate,
|
||||
leisureLevel: .moderate,
|
||||
numberOfDrivers: numberOfDrivers,
|
||||
maxDrivingHoursPerDriver: maxDrivingHoursPerDriver,
|
||||
allowRepeatCities: allowRepeatCities
|
||||
)
|
||||
|
||||
return PlanningRequest(
|
||||
preferences: preferences,
|
||||
availableGames: allGames,
|
||||
teams: teams,
|
||||
stadiums: stadiums
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: - 5A: Valid Inputs
|
||||
|
||||
@Test("5.1 - Single must-see game returns trip with that game")
|
||||
func test_mustSeeGames_SingleGame_ReturnsTripWithThatGame() {
|
||||
// Setup: Single must-see game
|
||||
let stadiumId = "stadium_test_\(UUID().uuidString)"
|
||||
let stadium = makeStadium(id: stadiumId, city: "Chicago", lat: 41.8781, lon: -87.6298)
|
||||
let stadiums = [stadiumId: stadium]
|
||||
|
||||
let gameId = "game_test_\(UUID().uuidString)"
|
||||
let game = makeGame(id: gameId, stadiumId: stadiumId, dateTime: makeDate(day: 10, hour: 19))
|
||||
|
||||
let request = makePlanningRequest(
|
||||
startDate: makeDate(day: 5, hour: 0),
|
||||
endDate: makeDate(day: 15, hour: 23),
|
||||
allGames: [game],
|
||||
mustSeeGameIds: [gameId],
|
||||
stadiums: stadiums
|
||||
)
|
||||
|
||||
// Execute
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// Verify
|
||||
#expect(result.isSuccess, "Should succeed with single must-see game")
|
||||
#expect(!result.options.isEmpty, "Should return at least one option")
|
||||
|
||||
if let firstOption = result.options.first {
|
||||
#expect(firstOption.totalGames >= 1, "Should have at least the must-see game")
|
||||
let allGameIds = firstOption.stops.flatMap { $0.games }
|
||||
#expect(allGameIds.contains(gameId), "Must-see game must be in the itinerary")
|
||||
}
|
||||
}
|
||||
|
||||
@Test("5.2 - Multiple must-see games returns optimal route")
|
||||
func test_mustSeeGames_MultipleGames_ReturnsOptimalRoute() {
|
||||
// Setup: 3 must-see games in nearby cities (all Central region for single-region search)
|
||||
// Region boundary: Central is -110 to -85 longitude
|
||||
let chicagoId = "stadium_chicago_\(UUID().uuidString)"
|
||||
let milwaukeeId = "stadium_milwaukee_\(UUID().uuidString)"
|
||||
let stLouisId = "stadium_stlouis_\(UUID().uuidString)"
|
||||
|
||||
// All cities in Central region (longitude between -110 and -85)
|
||||
let chicago = makeStadium(id: chicagoId, city: "Chicago", lat: 41.8781, lon: -87.6298)
|
||||
let milwaukee = makeStadium(id: milwaukeeId, city: "Milwaukee", lat: 43.0389, lon: -87.9065)
|
||||
let stLouis = makeStadium(id: stLouisId, city: "St. Louis", lat: 38.6270, lon: -90.1994)
|
||||
|
||||
let stadiums = [chicagoId: chicago, milwaukeeId: milwaukee, stLouisId: stLouis]
|
||||
|
||||
let game1Id = "game_test_1_\(UUID().uuidString)"
|
||||
let game2Id = "game_test_2_\(UUID().uuidString)"
|
||||
let game3Id = "game_test_3_\(UUID().uuidString)"
|
||||
|
||||
let game1 = makeGame(id: game1Id, stadiumId: chicagoId, dateTime: makeDate(day: 5, hour: 19))
|
||||
let game2 = makeGame(id: game2Id, stadiumId: milwaukeeId, dateTime: makeDate(day: 7, hour: 19))
|
||||
let game3 = makeGame(id: game3Id, stadiumId: stLouisId, dateTime: makeDate(day: 9, hour: 19))
|
||||
|
||||
let request = makePlanningRequest(
|
||||
startDate: makeDate(day: 4, hour: 0),
|
||||
endDate: makeDate(day: 10, hour: 23),
|
||||
allGames: [game1, game2, game3],
|
||||
mustSeeGameIds: [game1Id, game2Id, game3Id],
|
||||
stadiums: stadiums
|
||||
)
|
||||
|
||||
// Execute
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// Verify
|
||||
#expect(result.isSuccess, "Should succeed with multiple must-see games")
|
||||
#expect(!result.options.isEmpty, "Should return at least one option")
|
||||
|
||||
if let firstOption = result.options.first {
|
||||
let allGameIds = Set(firstOption.stops.flatMap { $0.games })
|
||||
#expect(allGameIds.contains(game1Id), "Must include game 1")
|
||||
#expect(allGameIds.contains(game2Id), "Must include game 2")
|
||||
#expect(allGameIds.contains(game3Id), "Must include game 3")
|
||||
|
||||
// Route should be in chronological order (respecting game times)
|
||||
#expect(firstOption.stops.count >= 3, "Should have at least 3 stops for 3 games in different cities")
|
||||
}
|
||||
}
|
||||
|
||||
@Test("5.3 - Games in different cities are connected")
|
||||
func test_mustSeeGames_GamesInDifferentCities_ConnectsThem() {
|
||||
// Setup: 2 must-see games in distant but reachable cities
|
||||
let nycId = "stadium_nyc_\(UUID().uuidString)"
|
||||
let bostonId = "stadium_boston_\(UUID().uuidString)"
|
||||
|
||||
// NYC to Boston is ~215 miles (~4 hours driving)
|
||||
let nyc = makeStadium(id: nycId, city: "New York", lat: 40.7128, lon: -73.9352)
|
||||
let boston = makeStadium(id: bostonId, city: "Boston", lat: 42.3601, lon: -71.0589)
|
||||
|
||||
let stadiums = [nycId: nyc, bostonId: boston]
|
||||
|
||||
let game1Id = "game_test_1_\(UUID().uuidString)"
|
||||
let game2Id = "game_test_2_\(UUID().uuidString)"
|
||||
|
||||
// Games 2 days apart - plenty of time to drive
|
||||
let game1 = makeGame(id: game1Id, stadiumId: nycId, dateTime: makeDate(day: 5, hour: 19))
|
||||
let game2 = makeGame(id: game2Id, stadiumId: bostonId, dateTime: makeDate(day: 7, hour: 19))
|
||||
|
||||
let request = makePlanningRequest(
|
||||
startDate: makeDate(day: 4, hour: 0),
|
||||
endDate: makeDate(day: 8, hour: 23),
|
||||
allGames: [game1, game2],
|
||||
mustSeeGameIds: [game1Id, game2Id],
|
||||
stadiums: stadiums
|
||||
)
|
||||
|
||||
// Execute
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// Verify
|
||||
#expect(result.isSuccess, "Should succeed connecting NYC and Boston")
|
||||
#expect(!result.options.isEmpty, "Should return at least one option")
|
||||
|
||||
if let firstOption = result.options.first {
|
||||
let allGameIds = Set(firstOption.stops.flatMap { $0.games })
|
||||
#expect(allGameIds.contains(game1Id), "Must include NYC game")
|
||||
#expect(allGameIds.contains(game2Id), "Must include Boston game")
|
||||
|
||||
// Should have travel segment between cities
|
||||
#expect(firstOption.travelSegments.count >= 1, "Should have travel segment(s)")
|
||||
|
||||
// Verify cities are connected in the route
|
||||
let cities = firstOption.stops.map { $0.city }
|
||||
#expect(cities.contains("New York"), "Route should include New York")
|
||||
#expect(cities.contains("Boston"), "Route should include Boston")
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - 5B: Edge Cases
|
||||
|
||||
@Test("5.4 - Empty selection returns failure")
|
||||
func test_mustSeeGames_EmptySelection_ThrowsError() {
|
||||
// Setup: No must-see games selected
|
||||
let stadiumId = "stadium_test_\(UUID().uuidString)"
|
||||
let stadium = makeStadium(id: stadiumId, city: "Chicago", lat: 41.8781, lon: -87.6298)
|
||||
let stadiums = [stadiumId: stadium]
|
||||
|
||||
let game = makeGame(stadiumId: stadiumId, dateTime: makeDate(day: 10, hour: 19))
|
||||
|
||||
// Empty must-see set
|
||||
let request = makePlanningRequest(
|
||||
startDate: makeDate(day: 5, hour: 0),
|
||||
endDate: makeDate(day: 15, hour: 23),
|
||||
allGames: [game],
|
||||
mustSeeGameIds: [], // Empty selection
|
||||
stadiums: stadiums
|
||||
)
|
||||
|
||||
// Execute
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// Verify: Should fail with appropriate error
|
||||
#expect(!result.isSuccess, "Should fail when no games selected")
|
||||
#expect(result.failure?.reason == .noValidRoutes,
|
||||
"Should return noValidRoutes (no selected games)")
|
||||
}
|
||||
|
||||
@Test("5.5 - Impossible to connect games returns failure")
|
||||
func test_mustSeeGames_ImpossibleToConnect_ThrowsError() {
|
||||
// Setup: Games on same day in cities ~850 miles apart (impossible in 8 hours)
|
||||
// Both cities in East region (> -85 longitude) so regional search covers both
|
||||
let nycId = "stadium_nyc_\(UUID().uuidString)"
|
||||
let atlantaId = "stadium_atlanta_\(UUID().uuidString)"
|
||||
|
||||
// NYC to Atlanta is ~850 miles (~13 hours driving) - impossible with 8-hour limit
|
||||
let nyc = makeStadium(id: nycId, city: "New York", lat: 40.7128, lon: -73.9352)
|
||||
let atlanta = makeStadium(id: atlantaId, city: "Atlanta", lat: 33.7490, lon: -84.3880)
|
||||
|
||||
let stadiums = [nycId: nyc, atlantaId: atlanta]
|
||||
|
||||
let game1Id = "game_test_1_\(UUID().uuidString)"
|
||||
let game2Id = "game_test_2_\(UUID().uuidString)"
|
||||
|
||||
// Same day games 6 hours apart - even if you left right after game 1,
|
||||
// you can't drive 850 miles in 6 hours with 8-hour daily limit
|
||||
let game1 = makeGame(id: game1Id, stadiumId: nycId, dateTime: makeDate(day: 5, hour: 13))
|
||||
let game2 = makeGame(id: game2Id, stadiumId: atlantaId, dateTime: makeDate(day: 5, hour: 19))
|
||||
|
||||
let request = makePlanningRequest(
|
||||
startDate: makeDate(day: 5, hour: 0),
|
||||
endDate: makeDate(day: 5, hour: 23),
|
||||
allGames: [game1, game2],
|
||||
mustSeeGameIds: [game1Id, game2Id],
|
||||
stadiums: stadiums,
|
||||
numberOfDrivers: 1,
|
||||
maxDrivingHoursPerDriver: 8.0
|
||||
)
|
||||
|
||||
// Execute
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// Verify: Should fail because it's impossible to connect these games
|
||||
// The planner should not find any valid route containing BOTH must-see games
|
||||
#expect(!result.isSuccess, "Should fail when games are impossible to connect")
|
||||
// Either noValidRoutes or constraintsUnsatisfiable are acceptable
|
||||
let validFailureReasons: [PlanningFailure.FailureReason] = [.noValidRoutes, .constraintsUnsatisfiable]
|
||||
#expect(validFailureReasons.contains(result.failure?.reason ?? .noValidRoutes),
|
||||
"Should return appropriate failure reason")
|
||||
}
|
||||
|
||||
@Test("5.6 - Max games selected handles gracefully", .timeLimit(.minutes(5)))
|
||||
func test_mustSeeGames_MaxGamesSelected_HandlesGracefully() {
|
||||
// Setup: Generate many games and select a large subset
|
||||
let config = FixtureGenerator.Configuration(
|
||||
seed: 42,
|
||||
gameCount: 500,
|
||||
stadiumCount: 30,
|
||||
teamCount: 60,
|
||||
dateRange: makeDate(day: 1, hour: 0)...makeDate(month: 8, day: 31, hour: 23),
|
||||
geographicSpread: .regional // Keep games in one region for feasibility
|
||||
)
|
||||
let data = FixtureGenerator.generate(with: config)
|
||||
|
||||
// Select 50 games as must-see (a stress test for the planner)
|
||||
let mustSeeGames = Array(data.games.prefix(50))
|
||||
let mustSeeIds = Set(mustSeeGames.map { $0.id })
|
||||
|
||||
let request = makePlanningRequest(
|
||||
startDate: makeDate(day: 1, hour: 0),
|
||||
endDate: makeDate(month: 8, day: 31, hour: 23),
|
||||
allGames: data.games,
|
||||
mustSeeGameIds: mustSeeIds,
|
||||
stadiums: data.stadiumsById
|
||||
)
|
||||
|
||||
// Execute with timing
|
||||
let startTime = Date()
|
||||
let result = planner.plan(request: request)
|
||||
let elapsed = Date().timeIntervalSince(startTime)
|
||||
|
||||
// Verify: Should complete without crash/hang
|
||||
#expect(elapsed < TestConstants.performanceTimeout,
|
||||
"Should complete within performance timeout")
|
||||
|
||||
// Result could be success or failure depending on feasibility
|
||||
// The key is that it doesn't crash or hang
|
||||
if result.isSuccess {
|
||||
// If successful, verify anchor games are included where possible
|
||||
if let firstOption = result.options.first {
|
||||
let includedGames = Set(firstOption.stops.flatMap { $0.games })
|
||||
let includedMustSee = includedGames.intersection(mustSeeIds)
|
||||
// Some must-see games should be included
|
||||
#expect(!includedMustSee.isEmpty, "Should include some must-see games")
|
||||
}
|
||||
}
|
||||
// Failure is also acceptable for extreme constraints
|
||||
}
|
||||
|
||||
// MARK: - 5C: Optimality Verification
|
||||
|
||||
@Test("5.7 - Small input matches brute force optimal")
|
||||
func test_mustSeeGames_SmallInput_MatchesBruteForceOptimal() {
|
||||
// Setup: 5 must-see games (within brute force threshold of 8)
|
||||
// All cities in East region (> -85 longitude) for single-region search
|
||||
// Geographic progression from north to south along the East Coast
|
||||
let boston = makeStadium(city: "Boston", lat: 42.3601, lon: -71.0589)
|
||||
let nyc = makeStadium(city: "New York", lat: 40.7128, lon: -73.9352)
|
||||
let philadelphia = makeStadium(city: "Philadelphia", lat: 39.9526, lon: -75.1652)
|
||||
let baltimore = makeStadium(city: "Baltimore", lat: 39.2904, lon: -76.6122)
|
||||
let dc = makeStadium(city: "Washington DC", lat: 38.9072, lon: -77.0369)
|
||||
|
||||
let stadiums = [
|
||||
boston.id: boston,
|
||||
nyc.id: nyc,
|
||||
philadelphia.id: philadelphia,
|
||||
baltimore.id: baltimore,
|
||||
dc.id: dc
|
||||
]
|
||||
|
||||
// Games spread over 2 weeks with clear geographic progression
|
||||
let game1 = makeGame(stadiumId: boston.id, dateTime: makeDate(day: 1, hour: 19))
|
||||
let game2 = makeGame(stadiumId: nyc.id, dateTime: makeDate(day: 3, hour: 19))
|
||||
let game3 = makeGame(stadiumId: philadelphia.id, dateTime: makeDate(day: 6, hour: 19))
|
||||
let game4 = makeGame(stadiumId: baltimore.id, dateTime: makeDate(day: 9, hour: 19))
|
||||
let game5 = makeGame(stadiumId: dc.id, dateTime: makeDate(day: 12, hour: 19))
|
||||
|
||||
let allGames = [game1, game2, game3, game4, game5]
|
||||
let mustSeeIds = Set(allGames.map { $0.id })
|
||||
|
||||
let request = makePlanningRequest(
|
||||
startDate: makeDate(day: 1, hour: 0),
|
||||
endDate: makeDate(day: 15, hour: 23),
|
||||
allGames: allGames,
|
||||
mustSeeGameIds: mustSeeIds,
|
||||
stadiums: stadiums
|
||||
)
|
||||
|
||||
// Execute
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// Verify success
|
||||
#expect(result.isSuccess, "Should succeed with 5 must-see games")
|
||||
guard let firstOption = result.options.first else {
|
||||
Issue.record("No options returned")
|
||||
return
|
||||
}
|
||||
|
||||
// Verify all must-see games are included
|
||||
let includedGameIds = Set(firstOption.stops.flatMap { $0.games })
|
||||
for gameId in mustSeeIds {
|
||||
#expect(includedGameIds.contains(gameId), "All must-see games should be included")
|
||||
}
|
||||
|
||||
// Build coordinate map for brute force verification
|
||||
var stopCoordinates: [String: CLLocationCoordinate2D] = [:]
|
||||
for stop in firstOption.stops {
|
||||
if let coord = stop.coordinate {
|
||||
stopCoordinates[stop.id.uuidString] = coord
|
||||
}
|
||||
}
|
||||
|
||||
// Only verify if we have enough stops with coordinates
|
||||
guard stopCoordinates.count >= 2 && stopCoordinates.count <= TestConstants.bruteForceMaxStops else {
|
||||
return
|
||||
}
|
||||
|
||||
let stopIds = firstOption.stops.map { $0.id.uuidString }
|
||||
let verificationResult = BruteForceRouteVerifier.verify(
|
||||
proposedRoute: stopIds,
|
||||
stops: stopCoordinates,
|
||||
tolerance: 0.15 // 15% tolerance for heuristic algorithms
|
||||
)
|
||||
|
||||
let message = verificationResult.failureMessage ?? "Route should be near-optimal"
|
||||
#expect(verificationResult.isOptimal, Comment(rawValue: message))
|
||||
}
|
||||
|
||||
@Test("5.8 - Large input has no obviously better route")
|
||||
func test_mustSeeGames_LargeInput_NoObviouslyBetterRoute() {
|
||||
// Setup: Generate more games than brute force can handle
|
||||
let config = FixtureGenerator.Configuration(
|
||||
seed: 123,
|
||||
gameCount: 200,
|
||||
stadiumCount: 20,
|
||||
teamCount: 40,
|
||||
dateRange: makeDate(day: 1, hour: 0)...makeDate(month: 7, day: 31, hour: 23),
|
||||
geographicSpread: .regional
|
||||
)
|
||||
let data = FixtureGenerator.generate(with: config)
|
||||
|
||||
// Select 15 games as must-see (more than brute force threshold)
|
||||
let mustSeeGames = Array(data.games.prefix(15))
|
||||
let mustSeeIds = Set(mustSeeGames.map { $0.id })
|
||||
|
||||
let request = makePlanningRequest(
|
||||
startDate: makeDate(day: 1, hour: 0),
|
||||
endDate: makeDate(month: 7, day: 31, hour: 23),
|
||||
allGames: data.games,
|
||||
mustSeeGameIds: mustSeeIds,
|
||||
stadiums: data.stadiumsById
|
||||
)
|
||||
|
||||
// Execute
|
||||
let result = planner.plan(request: request)
|
||||
|
||||
// If planning fails, that's acceptable for complex constraints
|
||||
guard result.isSuccess, let firstOption = result.options.first else {
|
||||
return
|
||||
}
|
||||
|
||||
// Verify some must-see games are included
|
||||
let includedGameIds = Set(firstOption.stops.flatMap { $0.games })
|
||||
let includedMustSee = includedGameIds.intersection(mustSeeIds)
|
||||
#expect(!includedMustSee.isEmpty, "Should include some must-see games")
|
||||
|
||||
// Build coordinate map
|
||||
var stopCoordinates: [String: CLLocationCoordinate2D] = [:]
|
||||
for stop in firstOption.stops {
|
||||
if let coord = stop.coordinate {
|
||||
stopCoordinates[stop.id.uuidString] = coord
|
||||
}
|
||||
}
|
||||
|
||||
// Check that there's no obviously better route (10% threshold)
|
||||
guard stopCoordinates.count >= 2 else { return }
|
||||
|
||||
let stopIds = firstOption.stops.map { $0.id.uuidString }
|
||||
let (hasBetter, improvement) = BruteForceRouteVerifier.hasObviouslyBetterRoute(
|
||||
proposedRoute: stopIds,
|
||||
stops: stopCoordinates,
|
||||
threshold: 0.10 // 10% improvement would be "obviously better"
|
||||
)
|
||||
|
||||
if hasBetter, let imp = improvement {
|
||||
// Only fail if the improvement is very significant
|
||||
#expect(imp < 0.25, "Route should not be more than 25% suboptimal")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user