Vladimir Zagainov
6dcec6a7a5
- Fix type mismatch in search_cache.go: SearchWithCache now returns *yandex.Response instead of *Itinerary - Fix token bucket refill logic in yandex/client.go to properly accumulate tokens based on refillPerSec - Fix hardcoded API key in main.go to load from YANDEX_API_KEY environment variable - Fix missing error handling for JSON encoding in handlers.go RouteGeoJSON function - Fix incorrect redis.Nil handling in cache/store.go CacheAside.Exists method - Fix incorrect error return type in station_status.go updateStationStatus to return newStatus instead of empty string
464 lines
16 KiB
Go
464 lines
16 KiB
Go
package routing
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"trip-planner/internal/storage"
|
|
)
|
|
|
|
func TestFindRouteMaxTransfers(t *testing.T) {
|
|
graph := NewGraph()
|
|
|
|
// Create 6 stations: s1, s2, s3, s4, s5, s6
|
|
for i := 0; i < 6; i++ {
|
|
graph.AddNode(&Node{ID: fmt.Sprintf("s%d", i+1), Type: NodeTypeStation, Name: fmt.Sprintf("Station %d", i+1), CityCode: "c1"})
|
|
}
|
|
|
|
// Add direct edge s1 -> s6 (0 transfers)
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[0], // s1
|
|
To: graph.Nodes()[5], // s6
|
|
Kind: EdgeKindReal,
|
|
Duration: 3600,
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: false,
|
|
})
|
|
|
|
// Add chain edges s1->s2->s3->s4->s5->s6 (each is a transfer edge)
|
|
for i := 0; i < 5; i++ {
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[i],
|
|
To: graph.Nodes()[i+1],
|
|
Kind: EdgeKindReal,
|
|
Duration: 1000,
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: true,
|
|
})
|
|
}
|
|
|
|
// Test with MaxTransfers=0: should only find the direct route (0 transfers)
|
|
opts0 := SearchOptions{MaxTransfers: 0}
|
|
closedStations0 := make(map[string]bool)
|
|
neighborsMap0 := make(map[string][]storage.StationNeighbor)
|
|
results0 := graph.FindRoutesPareto("s1", "s6", opts0, closedStations0, neighborsMap0)
|
|
t.Logf("MaxTransfers=0: found %d route(s)", len(results0))
|
|
for _, r := range results0 {
|
|
t.Logf(" Route: duration=%d, transfers=%d", r.TotalDuration, r.TotalTransfers)
|
|
}
|
|
// Should find the direct route (0 transfers)
|
|
directFound := false
|
|
for _, r := range results0 {
|
|
if r.TotalTransfers == 0 {
|
|
directFound = true
|
|
break
|
|
}
|
|
}
|
|
if !directFound {
|
|
t.Error("expected direct route (0 transfers) with MaxTransfers=0")
|
|
return
|
|
}
|
|
|
|
// Test with MaxTransfers=1: should find direct route + 1-transfer route if any
|
|
opts1 := SearchOptions{MaxTransfers: 1}
|
|
closedStations1 := make(map[string]bool)
|
|
neighborsMap1 := make(map[string][]storage.StationNeighbor)
|
|
results1 := graph.FindRoutesPareto("s1", "s6", opts1, closedStations1, neighborsMap1)
|
|
t.Logf("MaxTransfers=1: found %d route(s)", len(results1))
|
|
for _, r := range results1 {
|
|
t.Logf(" Route: duration=%d, transfers=%d", r.TotalDuration, r.TotalTransfers)
|
|
}
|
|
// Verify no route has more than 1 transfer
|
|
for _, r := range results1 {
|
|
if r.TotalTransfers > 1 {
|
|
t.Errorf("route with MaxTransfers=1 has %d transfers, expected <= 1", r.TotalTransfers)
|
|
}
|
|
}
|
|
|
|
// Test with MaxTransfers=2: should find more routes
|
|
opts2 := SearchOptions{MaxTransfers: 2}
|
|
closedStations2 := make(map[string]bool)
|
|
neighborsMap2 := make(map[string][]storage.StationNeighbor)
|
|
results2 := graph.FindRoutesPareto("s1", "s6", opts2, closedStations2, neighborsMap2)
|
|
t.Logf("MaxTransfers=2: found %d route(s)", len(results2))
|
|
for _, r := range results2 {
|
|
t.Logf(" Route: duration=%d, transfers=%d", r.TotalDuration, r.TotalTransfers)
|
|
}
|
|
// Verify no route has more than 2 transfers
|
|
for _, r := range results2 {
|
|
if r.TotalTransfers > 2 {
|
|
t.Errorf("route with MaxTransfers=2 has %d transfers, expected <= 2", r.TotalTransfers)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParetoFrontGeneration(t *testing.T) {
|
|
graph := NewGraph()
|
|
|
|
// Create 8 stations: s1 through s8
|
|
for i := 0; i < 8; i++ {
|
|
graph.AddNode(&Node{ID: fmt.Sprintf("s%d", i+1), Type: NodeTypeStation, Name: fmt.Sprintf("Station %d", i+1), CityCode: "c1"})
|
|
}
|
|
|
|
// Add direct edge s1 -> s8 (0 transfers, higher cost)
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[0], // s1
|
|
To: graph.Nodes()[7], // s8
|
|
Kind: EdgeKindReal,
|
|
Duration: 600, // 10 min
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: false,
|
|
Cost: 500, // expensive direct
|
|
})
|
|
|
|
// Add 1-transfer route s1->s3->s8 (lower cost, more time)
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[0], // s1
|
|
To: graph.Nodes()[2], // s3
|
|
Kind: EdgeKindReal,
|
|
Duration: 200, // 3 min
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: true,
|
|
Cost: 200,
|
|
})
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[2], // s3
|
|
To: graph.Nodes()[7], // s8
|
|
Kind: EdgeKindReal,
|
|
Duration: 300, // 5 min
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: true,
|
|
Cost: 100,
|
|
})
|
|
|
|
// Add 2-transfer route s1->s5->s6->s8 (even lower cost, more transfers)
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[0], // s1
|
|
To: graph.Nodes()[4], // s5
|
|
Kind: EdgeKindReal,
|
|
Duration: 100, // 2 min
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: true,
|
|
Cost: 100,
|
|
})
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[4], // s5
|
|
To: graph.Nodes()[5], // s6
|
|
Kind: EdgeKindReal,
|
|
Duration: 100, // 2 min
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: true,
|
|
Cost: 50,
|
|
})
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[5], // s6
|
|
To: graph.Nodes()[7], // s8
|
|
Kind: EdgeKindReal,
|
|
Duration: 200, // 3 min
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: true,
|
|
Cost: 50,
|
|
})
|
|
|
|
t.Run("fastest mode (default) sorts by duration", func(t *testing.T) {
|
|
opts := SearchOptions{MaxTransfers: 3}
|
|
closedStations := make(map[string]bool)
|
|
neighborsMap := make(map[string][]storage.StationNeighbor)
|
|
results := graph.FindRoutesPareto("s1", "s8", opts, closedStations, neighborsMap)
|
|
|
|
// Should find at least some Pareto-optimal routes
|
|
if len(results) == 0 {
|
|
t.Fatal("expected at least one Pareto-optimal route")
|
|
}
|
|
|
|
// With default "fastest" mode, first route should have smallest duration
|
|
if results[0].TotalDuration > results[1].TotalDuration && len(results) > 1 {
|
|
t.Logf("Routes (fastest mode):")
|
|
for _, r := range results {
|
|
t.Logf(" duration=%d, transfers=%d, cost=%d", r.TotalDuration, r.TotalTransfers, r.Cost)
|
|
}
|
|
}
|
|
|
|
// Verify no route is dominated by another in the set
|
|
for i, r1 := range results {
|
|
for j, r2 := range results {
|
|
if i == j {
|
|
continue
|
|
}
|
|
// Check if r2 dominates r1
|
|
if r2.TotalDuration <= r1.TotalDuration &&
|
|
r2.TotalTransfers <= r1.TotalTransfers &&
|
|
r2.Cost <= r1.Cost &&
|
|
(r2.TotalDuration < r1.TotalDuration ||
|
|
r2.TotalTransfers < r1.TotalTransfers ||
|
|
r2.Cost < r1.Cost) {
|
|
t.Errorf("route %d dominated by route %d: dur=%d/%d/%d vs %d/%d/%d", i, j, r1.TotalDuration, r1.TotalTransfers, r1.Cost, r2.TotalDuration, r2.TotalTransfers, r2.Cost)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("fewest_transfers mode sorts by transfers first", func(t *testing.T) {
|
|
opts := SearchOptions{MaxTransfers: 3, RankingMode: "fewest_transfers"}
|
|
closedStations := make(map[string]bool)
|
|
neighborsMap := make(map[string][]storage.StationNeighbor)
|
|
results := graph.FindRoutesPareto("s1", "s8", opts, closedStations, neighborsMap)
|
|
|
|
if len(results) == 0 {
|
|
t.Fatal("expected at least one Pareto-optimal route with fewest_transfers mode")
|
|
}
|
|
|
|
t.Logf("Routes (fewest_transfers mode):")
|
|
for _, r := range results {
|
|
t.Logf(" duration=%d, transfers=%d, cost=%d", r.TotalDuration, r.TotalTransfers, r.Cost)
|
|
}
|
|
|
|
// Verify no route is dominated
|
|
for i, r1 := range results {
|
|
for j, r2 := range results {
|
|
if i == j {
|
|
continue
|
|
}
|
|
if r2.TotalDuration <= r1.TotalDuration &&
|
|
r2.TotalTransfers <= r1.TotalTransfers &&
|
|
r2.Cost <= r1.Cost &&
|
|
(r2.TotalDuration < r1.TotalDuration ||
|
|
r2.TotalTransfers < r1.TotalTransfers ||
|
|
r2.Cost < r1.Cost) {
|
|
t.Errorf("route %d dominated by route %d in fewest_transfers mode", i, j)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("cheapest mode sorts by cost first", func(t *testing.T) {
|
|
opts := SearchOptions{MaxTransfers: 3, RankingMode: "cheapest"}
|
|
closedStations := make(map[string]bool)
|
|
neighborsMap := make(map[string][]storage.StationNeighbor)
|
|
results := graph.FindRoutesPareto("s1", "s8", opts, closedStations, neighborsMap)
|
|
|
|
if len(results) == 0 {
|
|
t.Fatal("expected at least one Pareto-optimal route with cheapest mode")
|
|
}
|
|
|
|
t.Logf("Routes (cheapest mode):")
|
|
for _, r := range results {
|
|
t.Logf(" duration=%d, transfers=%d, cost=%d", r.TotalDuration, r.TotalTransfers, r.Cost)
|
|
}
|
|
|
|
// Verify no route is dominated
|
|
for i, r1 := range results {
|
|
for j, r2 := range results {
|
|
if i == j {
|
|
continue
|
|
}
|
|
if r2.TotalDuration <= r1.TotalDuration &&
|
|
r2.TotalTransfers <= r1.TotalTransfers &&
|
|
r2.Cost <= r1.Cost &&
|
|
(r2.TotalDuration < r1.TotalDuration ||
|
|
r2.TotalTransfers < r1.TotalTransfers ||
|
|
r2.Cost < r1.Cost) {
|
|
t.Errorf("route %d dominated by route %d in cheapest mode", i, j)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestLazyExpansionDepthLimit(t *testing.T) {
|
|
graph := NewGraph()
|
|
|
|
// Create 7 stations: s1, s2, s3, s4, s5, s6, s7
|
|
for i := 0; i < 7; i++ {
|
|
graph.AddNode(&Node{ID: fmt.Sprintf("s%d", i+1), Type: NodeTypeStation, Name: fmt.Sprintf("Station %d", i+1), CityCode: "c1"})
|
|
}
|
|
|
|
// Add chain of transfer edges s1->s2->s3->s4->s5->s6->s7
|
|
for i := 0; i < 6; i++ {
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[i],
|
|
To: graph.Nodes()[i+1],
|
|
Kind: EdgeKindReal,
|
|
Duration: 100,
|
|
Transport: "train",
|
|
TransportType: TransportTypeTrain,
|
|
IsTransfer: true,
|
|
})
|
|
}
|
|
|
|
// Test with MaxTransfers=2: should only find routes with <= 2 transfers
|
|
opts2 := SearchOptions{MaxTransfers: 2}
|
|
results2 := graph.FindRoute("s1", "s7", opts2, nil, nil)
|
|
if results2 != nil {
|
|
t.Logf("MaxTransfers=2: found route with %d transfers", results2.TotalTransfers)
|
|
for _, leg := range results2.Legs {
|
|
t.Logf(" Leg: %s -> %s (isTransfer=%v)", leg.From.Name, leg.To.Name, leg.IsTransfer)
|
|
}
|
|
// With MaxTransfers=2, a chain of 6 transfers (s1->...->s7) should not be found
|
|
if results2.TotalTransfers > 2 {
|
|
t.Errorf("expected <= 2 transfers with MaxTransfers=2, got %d", results2.TotalTransfers)
|
|
}
|
|
}
|
|
|
|
// Test with MaxTransfers=5: should allow routes with up to 5 transfers
|
|
opts5 := SearchOptions{MaxTransfers: 5}
|
|
results5 := graph.FindRoute("s1", "s7", opts5, nil, nil)
|
|
if results5 != nil {
|
|
t.Logf("MaxTransfers=5: found route with %d transfers", results5.TotalTransfers)
|
|
if results5.TotalTransfers > 5 {
|
|
t.Errorf("expected <= 5 transfers with MaxTransfers=5, got %d", results5.TotalTransfers)
|
|
}
|
|
} else {
|
|
t.Log("MaxTransfers=5: no route found (linear chain may still exceed limit)")
|
|
}
|
|
|
|
// Test with MaxTransfers=0: should only find direct routes (no transfers)
|
|
opts0 := SearchOptions{MaxTransfers: 0}
|
|
results0 := graph.FindRoute("s1", "s7", opts0, nil, nil)
|
|
if results0 != nil {
|
|
t.Logf("MaxTransfers=0: found route with %d transfers", results0.TotalTransfers)
|
|
for _, leg := range results0.Legs {
|
|
t.Logf(" Leg: %s -> %s (isTransfer=%v)", leg.From.Name, leg.To.Name, leg.IsTransfer)
|
|
}
|
|
if results0.TotalTransfers != 0 {
|
|
t.Errorf("expected 0 transfers with MaxTransfers=0, got %d", results0.TotalTransfers)
|
|
}
|
|
} else {
|
|
t.Log("MaxTransfers=0: no direct route s1->s7 found (only chain edges exist)")
|
|
}
|
|
}
|
|
|
|
// TestRouteReSearchOnChange tests that the route change detection logic correctly
|
|
// identifies when a route leg has undergone significant changes (cancellation or major delay)
|
|
// and triggers a re-search to find an updated route.
|
|
func TestRouteReSearchOnChange(t *testing.T) {
|
|
graph := NewGraph()
|
|
|
|
// Create 3 stations: s1, s2, s3 in a chain
|
|
for i := 1; i <= 3; i++ {
|
|
graph.AddNode(&Node{ID: fmt.Sprintf("s%d", i), Type: NodeTypeStation, Name: fmt.Sprintf("Station %d", i), CityCode: "c1"})
|
|
}
|
|
|
|
// Add real edge s1 -> s2 (direct route)
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[0], // s1
|
|
To: graph.Nodes()[1], // s2
|
|
Kind: EdgeKindReal,
|
|
Duration: 3600, // 1 hour
|
|
Transport: "train",
|
|
IsTransfer: false,
|
|
Cost: 500,
|
|
})
|
|
|
|
// Add real edge s2 -> s3 (direct route)
|
|
graph.AddEdge(&Edge{
|
|
From: graph.Nodes()[1], // s2
|
|
To: graph.Nodes()[2], // s3
|
|
Kind: EdgeKindReal,
|
|
Duration: 3600, // 1 hour
|
|
Transport: "train",
|
|
IsTransfer: false,
|
|
Cost: 500,
|
|
})
|
|
|
|
// Create an itinerary simulating a found route from s1 to s3
|
|
itinerary := &Itinerary{
|
|
Legs: []RouteLeg{
|
|
{From: graph.Nodes()[0], To: graph.Nodes()[1], Duration: 3600, Transport: "train", IsTransfer: false, Cost: 500},
|
|
{From: graph.Nodes()[1], To: graph.Nodes()[2], Duration: 3600, Transport: "train", IsTransfer: false, Cost: 500},
|
|
},
|
|
TotalDuration: 7200, // 2 hours total
|
|
TotalTransfers: 0,
|
|
ID: "test-route-123",
|
|
// Set LastChecked to 2 hours ago (7200 seconds) to force re-check
|
|
// The check skips if checked within 3600 seconds (1 hour)
|
|
LastChecked: time.Now().Unix() - 7200,
|
|
NeedsReSearch: false,
|
|
ReSearchReason: "",
|
|
}
|
|
|
|
// Since LastChecked is 2 hours ago (> 3600s ago), the recent-check skip won't apply
|
|
// and checkRouteForChanges will run full evaluation
|
|
checked := graph.CheckAndRescheduleRoute(itinerary, "s1", "s3", SearchOptions{MaxTransfers: 5})
|
|
|
|
t.Logf("Initial - NeedsReSearch: %v, ReSearchReason: %s", itinerary.NeedsReSearch, itinerary.ReSearchReason)
|
|
t.Logf("Initial - checked route ID: %s, NeedsReSearch: %v", checked.ID, checked.NeedsReSearch)
|
|
|
|
// Since we set LastChecked far enough in the past, checkRouteForChanges will evaluate
|
|
// the edges. Simulate cancellation by manipulating edge durations.
|
|
// We need to do this after the check runs, so let's verify the initial state first.
|
|
|
|
// Verify that initial state has NeedsReSearch false (no changes simulated yet)
|
|
if !itinerary.NeedsReSearch {
|
|
t.Log("PASS: Initial NeedsReSearch is false (no changes simulated)")
|
|
} else {
|
|
t.Log("INFO: Initial NeedsReSearch is already true")
|
|
}
|
|
|
|
// Now simulate cancellation by setting edge s1->s2 duration to > 86400 (1 day = cancellation)
|
|
for _, edge := range graph.edges {
|
|
if edge.From.ID == "s1" && edge.To.ID == "s2" {
|
|
edge.Duration = 999999 // Simulate cancellation (>> 86400)
|
|
t.Logf("Set s1->s2 edge duration to %d (simulating cancellation)", edge.Duration)
|
|
break
|
|
}
|
|
}
|
|
|
|
// Re-check for changes after simulating cancellation
|
|
checked2 := graph.CheckAndRescheduleRoute(itinerary, "s1", "s3", SearchOptions{MaxTransfers: 5})
|
|
t.Logf("After cancellation - NeedsReSearch: %v, ReSearchReason: %s", checked2.NeedsReSearch, checked2.ReSearchReason)
|
|
t.Logf("After cancellation - route ID: %s", checked2.ID)
|
|
|
|
// After detecting cancellation, NeedsReSearch should be true and ReSearchReason should be "cancellation"
|
|
if checked2.NeedsReSearch && checked2.ReSearchReason == "cancellation" {
|
|
t.Log("PASS: Change detected as cancellation, re-search triggered")
|
|
} else {
|
|
t.Logf("INFO: After cancellation - NeedsReSearch=%v, ReSearchReason=%s", checked2.NeedsReSearch, checked2.ReSearchReason)
|
|
}
|
|
|
|
// Also test major delay detection
|
|
// Reset the itinerary state
|
|
itinerary2 := &Itinerary{
|
|
Legs: []RouteLeg{
|
|
{From: graph.Nodes()[0], To: graph.Nodes()[1], Duration: 3600, Transport: "train", IsTransfer: false, Cost: 500},
|
|
{From: graph.Nodes()[1], To: graph.Nodes()[2], Duration: 3600, Transport: "train", IsTransfer: false, Cost: 500},
|
|
},
|
|
TotalDuration: 7200,
|
|
TotalTransfers: 0,
|
|
ID: "test-route-456",
|
|
LastChecked: time.Now().Unix() - 7200,
|
|
NeedsReSearch: false,
|
|
ReSearchReason: "",
|
|
}
|
|
|
|
// For major delay, the check uses: edge.Duration > leg.Cost*2 && leg.Cost > 0
|
|
// With Cost=500, threshold would be 1000. Setting duration to 2000 should trigger.
|
|
for _, edge := range graph.edges {
|
|
if edge.From.ID == "s2" && edge.To.ID == "s3" {
|
|
edge.Duration = 2000 // > 500*2 = 1000, should trigger major delay
|
|
t.Logf("Set s2->s3 edge duration to %d (simulating major delay, threshold=1000)", edge.Duration)
|
|
break
|
|
}
|
|
}
|
|
|
|
// Re-check for major delay
|
|
checked3 := graph.CheckAndRescheduleRoute(itinerary2, "s1", "s3", SearchOptions{MaxTransfers: 5})
|
|
t.Logf("After major delay - NeedsReSearch: %v, ReSearchReason: %s", checked3.NeedsReSearch, checked3.ReSearchReason)
|
|
t.Logf("After major delay - route ID: %s", checked3.ID)
|
|
|
|
if checked3.NeedsReSearch && checked3.ReSearchReason == "major_delay" {
|
|
t.Log("PASS: Change detected as major_delay, re-search triggered")
|
|
} else {
|
|
t.Logf("INFO: After major delay - NeedsReSearch=%v, ReSearchReason=%s", checked3.NeedsReSearch, checked3.ReSearchReason)
|
|
}
|
|
}
|