fix: Sort trips by ID for deterministic trip selection and consistent test results.

Author: AhmedAlian7

internal/restapi/stops_for_location_handler.go

@@ -167,7 +167,7 @@ func (api *RestAPI) stopsForLocationHandler(w http.ResponseWriter, r *http.Reque
 
 		agencyId, _, err := utils.ExtractAgencyIDAndCodeID(routeIDStr)
 		if err != nil {
-			continue  // Skip malformed route IDs
+			continue // Skip malformed route IDs
 		}
 		stopRouteIDs[stopID] = append(stopRouteIDs[stopID], routeIDStr)
 		agencyIDs[agencyId] = true

internal/restapi/stops_for_route_handler.go

@@ -335,6 +335,12 @@ func processTripGroups(
 
 	for _, key := range keys {
 		tripsInGroup := tripGroups[key]
+
+		// Sort trips by ID to ensure we always pick the same representative trip
+		sort.Slice(tripsInGroup, func(i, j int) bool {
+			return tripsInGroup[i].ID < tripsInGroup[j].ID
+		})
+
 		representativeTrip := tripsInGroup[0]
 		stopsList, err := api.GtfsManager.GtfsDB.Queries.GetOrderedStopIDsForTrip(ctx, representativeTrip.ID)
 		if err != nil {

internal/restapi/stops_for_route_handler_test.go

@@ -75,9 +75,8 @@ func TestStopsForRouteHandlerEndToEnd(t *testing.T) {
 	inboundStopIds, ok := inboundGroup["stopIds"].([]interface{})
 	require.True(t, ok)
 
-	// TODO: why is this varying between 21 and 22 depending on the test run?
-	either21Or22 := len(inboundStopIds) == 21 || len(inboundStopIds) == 22
-	assert.True(t, either21Or22, "Expected 21 or 22 stop IDs, got %d", len(inboundStopIds))
+	// With deterministic sorting, checks should be consistent
+	assert.Equal(t, 21, len(inboundStopIds))
 
 	inboundPolylines, ok := inboundGroup["polylines"].([]interface{})
 	require.True(t, ok)
@@ -95,9 +94,8 @@ func TestStopsForRouteHandlerEndToEnd(t *testing.T) {
 
 	outboundStopIds, ok := outboundGroup["stopIds"].([]interface{})
 	require.True(t, ok)
-	// TODO: why is this varying between 21 and 22 depending on the test run?
-	either21Or22 = len(outboundStopIds) == 21 || len(outboundStopIds) == 22
-	assert.True(t, either21Or22, "Expected 21 or 22 stop IDs, got %d", len(outboundStopIds))
+	// With deterministic sorting, checks should be consistent
+	assert.Equal(t, 22, len(outboundStopIds))
 
 	// Verify references
 	refs, ok := data["references"].(map[string]interface{})

internal/restapi/test_helper_test.go

@@ -11,7 +11,7 @@ import (
 
 type mockTestingFatalf struct {
 	failed bool
-	err string
+	err    string
 }
 
 func (m *mockTestingFatalf) Fatalf(format string, args ...any) {
@@ -22,11 +22,9 @@ func (m *mockTestingFatalf) Fatalf(format string, args ...any) {
 
 func TestCollectAllNestedIdsFromObjects(t *testing.T) {
 	data := []interface{}{
-		map[string]interface{}{"routes":
-			[]interface{}{"234", "235"},
+		map[string]interface{}{"routes": []interface{}{"234", "235"},
 		},
-		map[string]interface{}{"routes":
-			[]interface{}{"345"},
+		map[string]interface{}{"routes": []interface{}{"345"},
 		},
 	}
 	expected := []string{"234", "235", "345"}
@@ -42,33 +40,32 @@ func TestCollectAllNestedIdsFromObjectsFailures(t *testing.T) {
 		expectedError string
 	}{
 		{
-			name:          "Invalid object type in the array",
-			data:          []interface{}{
-			                       map[int]interface{}{1: "234"},
-			               },
+			name: "Invalid object type in the array",
+			data: []interface{}{
+				map[int]interface{}{1: "234"},
+			},
 			expectedError: "item 0 is not a map[string]interface{}",
 		},
 		{
-			name:          "Missing key from the object",
-			data:          []interface{}{
-			                       map[string]interface{}{"id": "234"},
-			               },
+			name: "Missing key from the object",
+			data: []interface{}{
+				map[string]interface{}{"id": "234"},
+			},
 			expectedError: "item 0 missing key \"routes\"",
 		},
 		{
-			name:          "Invalid nested object",
-			data:          []interface{}{
-			                       map[string]interface{}{"routes": "234"},
-			               },
+			name: "Invalid nested object",
+			data: []interface{}{
+				map[string]interface{}{"routes": "234"},
+			},
 			expectedError: "item 0 key \"routes\" is not a []interface{}: string",
 		},
 		{
-			name:          "Invalid nested array type",
-			data:          []interface{}{
-			                       map[string]interface{}{"routes":
-			                               []interface{}{234},
-			                       },
-			               },
+			name: "Invalid nested array type",
+			data: []interface{}{
+				map[string]interface{}{"routes": []interface{}{234},
+				},
+			},
 			expectedError: "item 0 key \"routes\" index 0 is not a string: int",
 		},
 	}
@@ -109,24 +106,24 @@ func TestCollectAllIdsFromObjectsFailures(t *testing.T) {
 		expectedError string
 	}{
 		{
-			name:          "Invalid object type in the array",
-			data:          []interface{}{
-			                       map[int]interface{}{1: "234"},
-			               },
+			name: "Invalid object type in the array",
+			data: []interface{}{
+				map[int]interface{}{1: "234"},
+			},
 			expectedError: "item 0 is not a map[string]interface{}",
 		},
 		{
-			name:          "Missing key from the object",
-			data:          []interface{}{
-			                       map[string]interface{}{"name": "234"},
-			               },
+			name: "Missing key from the object",
+			data: []interface{}{
+				map[string]interface{}{"name": "234"},
+			},
 			expectedError: "item 0 missing key \"id\"",
 		},
 		{
-			name:          "Invalid nested object",
-			data:          []interface{}{
-			                       map[string]interface{}{"id": 234},
-			               },
+			name: "Invalid nested object",
+			data: []interface{}{
+				map[string]interface{}{"id": 234},
+			},
 			expectedError: "item 0 key \"id\" is not a string: int",
 		},
 	}