feat: fix E012 compliance and add bearing/speed ingest validation

Author: diveshpatil9104

handlers.go

@@ -64,6 +64,12 @@ func (r *LocationReport) validate() error {
 	if r.Timestamp < now-int64(maxTimestampSkew.Seconds()) || r.Timestamp > now+int64(maxTimestampSkew.Seconds()) {
 		return fmt.Errorf("timestamp must be within %d minutes of server time", int(maxTimestampSkew.Minutes()))
 	}
+	if r.Bearing < 0 || r.Bearing > 360 {
+		return fmt.Errorf("bearing must be between 0 and 360 (inclusive)")
+	}
+	if r.Speed < 0 {
+		return fmt.Errorf("speed must be non-negative")
+	}
 	return nil
 }
 
@@ -169,15 +175,20 @@ func buildFeed(vehicles []*VehicleState) *gtfs.FeedMessage {
 	version := "2.0"
 	inc := gtfs.FeedHeader_FULL_DATASET
 
-	feed := &gtfs.FeedMessage{
-		Header: &gtfs.FeedHeader{
-			GtfsRealtimeVersion: &version,
-			Incrementality:      &inc,
-			Timestamp:           &now,
-		},
-	}
+	// E012 (gtfs-realtime-validator): header.timestamp must be >= all entity timestamps.
+	headerTimestamp := now
 
+	var entities []*gtfs.FeedEntity
 	for _, v := range vehicles {
+		if v.Timestamp <= 0 {
+			slog.Warn("buildFeed: skipping vehicle with non-positive timestamp", "vehicle_id", v.VehicleID, "timestamp", v.Timestamp)
+			continue
+		}
+		ts := uint64(v.Timestamp)
+		if ts > headerTimestamp {
+			headerTimestamp = ts
+		}
+
 		entity := &gtfs.FeedEntity{
 			Id: proto.String(v.VehicleID),
 			Vehicle: &gtfs.VehiclePosition{
@@ -190,18 +201,25 @@ func buildFeed(vehicles []*VehicleState) *gtfs.FeedMessage {
 					Bearing:   proto.Float32(float32(v.Bearing)),
 					Speed:     proto.Float32(float32(v.Speed)),
 				},
-				Timestamp: proto.Uint64(uint64(v.Timestamp)),
+				Timestamp: proto.Uint64(ts),
 			},
 		}
 		if v.TripID != "" {
 			entity.Vehicle.Trip = &gtfs.TripDescriptor{
 				TripId: proto.String(v.TripID),
 			}
 		}
-		feed.Entity = append(feed.Entity, entity)
+		entities = append(entities, entity)
 	}
 
-	return feed
+	return &gtfs.FeedMessage{
+		Header: &gtfs.FeedHeader{
+			GtfsRealtimeVersion: &version,
+			Incrementality:      &inc,
+			Timestamp:           &headerTimestamp,
+		},
+		Entity: entities,
+	}
 }
 
 type adminStatusResponse struct {

handlers_test.go

@@ -102,6 +102,11 @@ func TestBuildFeed_WithVehicles(t *testing.T) {
 
 	require.NotNil(t, bus2)
 	assert.Nil(t, bus2.Vehicle.Trip, "bus-2 has no trip, Trip should be nil")
+
+	// E012: header timestamp must be >= max entity timestamp.
+	// 1752566500 is the larger of the two vehicle timestamps above (bus-2).
+	assert.GreaterOrEqual(t, feed.Header.GetTimestamp(), uint64(1752566500),
+		"header timestamp must be >= max entity timestamp (E012)")
 }
 
 func TestGetFeed_Protobuf(t *testing.T) {
@@ -231,6 +236,36 @@ func TestHandlePostLocation_Validation(t *testing.T) {
 			loc:  LocationReport{VehicleID: "bus-1", Latitude: 1, Longitude: 2, Timestamp: time.Now().Unix() + 600},
 			want: "timestamp must be within 5 minutes of server time",
 		},
+		{
+			name: "bearing negative",
+			loc:  LocationReport{VehicleID: "bus-1", Latitude: 1, Longitude: 2, Bearing: -1, Timestamp: time.Now().Unix()},
+			want: "bearing must be between 0 and 360 (inclusive)",
+		},
+		{
+			name: "bearing too high",
+			loc:  LocationReport{VehicleID: "bus-1", Latitude: 1, Longitude: 2, Bearing: 361, Timestamp: time.Now().Unix()},
+			want: "bearing must be between 0 and 360 (inclusive)",
+		},
+		{
+			name: "speed negative",
+			loc:  LocationReport{VehicleID: "bus-1", Latitude: 1, Longitude: 2, Speed: -5, Timestamp: time.Now().Unix()},
+			want: "speed must be non-negative",
+		},
+		{
+			name: "bearing just below zero",
+			loc:  LocationReport{VehicleID: "bus-1", Latitude: 1, Longitude: 2, Bearing: -0.001, Timestamp: time.Now().Unix()},
+			want: "bearing must be between 0 and 360 (inclusive)",
+		},
+		{
+			name: "bearing just above 360",
+			loc:  LocationReport{VehicleID: "bus-1", Latitude: 1, Longitude: 2, Bearing: 360.001, Timestamp: time.Now().Unix()},
+			want: "bearing must be between 0 and 360 (inclusive)",
+		},
+		{
+			name: "speed just below zero",
+			loc:  LocationReport{VehicleID: "bus-1", Latitude: 1, Longitude: 2, Speed: -0.001, Timestamp: time.Now().Unix()},
+			want: "speed must be non-negative",
+		},
 	}
 
 	for _, tc := range tests {
@@ -669,3 +704,37 @@ func TestHandlePostLocation_RateLimitDifferentVehiclesAreIndependent(t *testing.
 	assert.Equal(t, http.StatusTooManyRequests, postLocationWithClaims(handler, locA, claimsA).Code)
 	assert.Equal(t, http.StatusTooManyRequests, postLocationWithClaims(handler, locB, claimsB).Code)
 }
+
+func TestHandlePostLocation_BearingSpeedBoundaries(t *testing.T) {
+	tracker := NewTracker(5 * time.Minute)
+	defer tracker.Stop()
+
+	tests := []struct {
+		name string
+		sub  string
+		loc  LocationReport
+	}{
+		{"bearing exactly 0 (north)", "driver-bearing-0", LocationReport{
+			VehicleID: "bus-1", Latitude: 1, Longitude: 2,
+			Bearing: 0, Timestamp: time.Now().Unix()}},
+		{"bearing exactly 360", "driver-bearing-360", LocationReport{
+			VehicleID: "bus-2", Latitude: 1, Longitude: 2,
+			Bearing: 360, Timestamp: time.Now().Unix()}},
+		{"bearing 359.99", "driver-bearing-359", LocationReport{
+			VehicleID: "bus-3", Latitude: 1, Longitude: 2,
+			Bearing: 359.99, Timestamp: time.Now().Unix()}},
+		{"speed exactly 0 (stationary)", "driver-speed-0", LocationReport{
+			VehicleID: "bus-4", Latitude: 1, Longitude: 2,
+			Speed: 0, Timestamp: time.Now().Unix()}},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			mStore := &mockStore{}
+			handler := handlePostLocation(mStore, tracker, NewVehicleRateLimiter())
+			w := postLocationWithClaims(handler, tc.loc, jwt.MapClaims{"sub": tc.sub})
+			assert.Equal(t, http.StatusCreated, w.Code, "boundary value should be accepted")
+			assert.True(t, mStore.saved, "boundary value should have been saved")
+		})
+	}
+}