Mrixs/trip-planner
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Implement user preferences (saved cities, search history) with Redis storage and API handlers

Browse Source
This commit is contained in:
Vladimir Zagainov
2026-08-17 14:30:54 +03:00
parent 2907ed3e0d
commit 5842667fff
8 changed files with 1073 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

209
cmd/api/handlers.go
View File

@@ -2,6 +2,7 @@ package main
import (
"encoding/json"
"fmt"
"net/http"
"strings"
@@ -20,6 +21,7 @@ type HandlerContext struct {
Router *routing.Graph
Yandex *yandex.Client
SearchCache *routing.SearchCacheService
Preferences *cache.Preferences
}
// stationStatusResponse represents the response for station status.
@@ -35,8 +37,16 @@ type cityResponse []string
// routeSearchResponse represents the response for route search.
type routeSearchResponse struct {
Routes []interface{} `json:"routes"`
Count int `json:"count"`
Routes []routeSearchRoute `json:"routes"`
Count int `json:"count"`
}
type routeSearchRoute struct {
Duration int `json:"duration"`
Transfers int `json:"transfers"`
Cost int `json:"cost"`
ID string `json:"id"`
PriceNote string `json:"price_note,omitempty"` // "цена не указана" if price data not available from API
}
// routeGeoJSONResponse represents the response for route GeoJSON.
@@ -192,13 +202,15 @@ func RouteSearch(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
results := hc.Router.FindRoutesPareto(req.FromCityID, req.ToCityID, opts)
// Build response routes
routeResponses := make([]interface{}, 0, len(results))
routeResponses := make([]routeSearchRoute, 0, len(results))
for _, route := range results {
routeResponses = append(routeResponses, map[string]interface{}{
"duration": route.TotalDuration,
"transfers": route.TotalTransfers,
"cost": route.Cost,
"id": route.ID,
priceNote := "цена не указана"
routeResponses = append(routeResponses, routeSearchRoute{
Duration: route.TotalDuration,
Transfers: route.TotalTransfers,
Cost: route.Cost,
ID: route.ID,
PriceNote: priceNote,
})
}
@@ -223,6 +235,20 @@ func RouteGeoJSON(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
// Real edges (actual scheduled trips) are solid lines
features := make([]map[string]interface{}, 0)
// Collect transfer points: nodes that are destinations of transfer edges
// and have connections to other edges (for popup markers).
transferNodeIDs := make(map[string]bool)
for _, edge := range hc.Router.Edges() {
if edge.IsTransfer {
transferNodeIDs[edge.To.ID] = true
transferNodeIDs[edge.From.ID] = true
}
}
// Track which edges have been added to avoid duplicates when
// a transfer node appears in multiple edges.
addedEdges := make(map[string]bool)
for _, edge := range hc.Router.Edges() {
// Determine line style based on edge type
strokeColor := "#1976d2" // default blue for train
@@ -247,8 +273,12 @@ func RouteGeoJSON(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
fromCoord := []float64{0, 0} // placeholder
toCoord := []float64{0, 0} // placeholder
// In a full implementation, would use actual node coordinates from PostGIS
// For now, use fixed placeholder coordinates
key := edge.From.ID + ":" + edge.To.ID
if addedEdges[key] {
continue
}
addedEdges[key] = true
geoJsonLine := map[string]interface{}{
"type": "LineString",
"coordinates": []interface{}{
@@ -257,7 +287,7 @@ func RouteGeoJSON(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
"properties": map[string]interface{}{
"transport": edge.Transport,
"transport_type": string(edge.TransportType),
"kind": "real",
"kind": fmt.Sprintf("%v", edge.Kind),
"synthetic": edge.Synthetic,
"duration": edge.Duration,
"cost": edge.Cost,
@@ -271,8 +301,36 @@ func RouteGeoJSON(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
features = append(features, map[string]interface{}{
"type": "Feature",
"geometry": geoJsonLine,
"properties": map[string]interface{}{},
"properties": geoJsonLine["properties"],
})
// Add transfer point markers at nodes that are transfer destinations
if edge.IsTransfer && transferNodeIDs[edge.To.ID] {
// Use default 30 min (1800s) MCT if no specific rule applies
connectionTime := 1800 // default MCT: 30 minutes
// Add a Point feature for the transfer marker
transferFeature := map[string]interface{}{
"type": "Feature",
"geometry": map[string]interface{}{
"type": "Point",
"coordinates": []float64{
0, 0, // placeholder - would use node coordinates from PostGIS
},
},
"properties": map[string]interface{}{
"marker_type": "transfer",
"title": edge.To.Name,
"connection_time": connectionTime,
"connection_time_formatted": fmt.Sprintf("%d min", connectionTime/60),
"transfer_type": edge.Transport,
"is_transfer": true,
"stroke_color": strokeColor,
"stroke_width": 2,
},
}
features = append(features, transferFeature)
}
}
resp := routeGeoJSONResponse{
@@ -414,6 +472,132 @@ func logStatusOverride(stationID, status, source string) {
// Could log to: external logging service, database, etc.
}
// preferenceResponse represents the response for preference endpoints.
type preferenceResponse struct {
Message string `json:"message"`
Data interface{} `json:"data,omitempty"`
Error string `json:"error,omitempty"`
}
// getSavedCitiesHandler handles GET /v1/preferences/saved-cities.
func GetSavedCities(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
userID := r.URL.Query().Get("user_id")
if userID == "" {
userID = "default"
}
cities, err := hc.Preferences.GetSavedCities(r.Context(), userID)
if err != nil {
http.Error(w, "failed to get saved cities: "+err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(preferenceResponse{
Message: "saved cities retrieved",
Data: cities,
})
}
// addSavedCityHandler handles POST /v1/preferences/saved-cities.
func AddSavedCity(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
userID := r.URL.Query().Get("user_id")
if userID == "" {
userID = "default"
}
var req struct {
CityCode string `json:"city_code"`
Name string `json:"name"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid request body", http.StatusBadRequest)
return
}
if err := hc.Preferences.AddSavedCity(r.Context(), userID, req.CityCode, req.Name); err != nil {
http.Error(w, "failed to add saved city: "+err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(preferenceResponse{
Message: "saved city added",
})
}
// removeSavedCityHandler handles DELETE /v1/preferences/saved-cities/{city_code}.
func RemoveSavedCity(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
userID := r.URL.Query().Get("user_id")
if userID == "" {
userID = "default"
}
cityCode := strings.TrimPrefix(r.URL.Path, "/v1/preferences/saved-cities/")
if cityCode == "" || cityCode == "/v1/preferences/saved-cities/" {
http.Error(w, "missing city code", http.StatusBadRequest)
return
}
if err := hc.Preferences.RemoveSavedCity(r.Context(), userID, cityCode); err != nil {
http.Error(w, "failed to remove saved city: "+err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(preferenceResponse{
Message: "saved city removed",
})
}
// getSearchHistoryHandler handles GET /v1/preferences/search-history.
func GetSearchHistory(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
userID := r.URL.Query().Get("user_id")
if userID == "" {
userID = "default"
}
history, err := hc.Preferences.GetSearchHistory(r.Context(), userID)
if err != nil {
http.Error(w, "failed to get search history: "+err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(preferenceResponse{
Message: "search history retrieved",
Data: history,
})
}
// addSearchHistoryHandler handles POST /v1/preferences/search-history.
func AddSearchHistory(hc *HandlerContext, w http.ResponseWriter, r *http.Request) {
userID := r.URL.Query().Get("user_id")
if userID == "" {
userID = "default"
}
var req struct {
FromCity string `json:"from_city"`
ToCity string `json:"to_city"`
Date string `json:"date"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, "invalid request body", http.StatusBadRequest)
return
}
if err := hc.Preferences.AddSearchHistory(r.Context(), userID, req.FromCity, req.ToCity, req.Date); err != nil {
http.Error(w, "failed to add search history: "+err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(preferenceResponse{
Message: "search history added",
})
}
// NewHandlerContext creates a new HandlerContext with initialized services.
func NewHandlerContext(redisClient *redis.Client, router *routing.Graph, yandex *yandex.Client) *HandlerContext {
cacheStore := cache.NewCacheStore(redisClient)
@@ -423,5 +607,6 @@ func NewHandlerContext(redisClient *redis.Client, router *routing.Graph, yandex
Router: router,
Yandex: yandex,
SearchCache: routing.NewSearchCacheService(cache.NewCacheAside(cacheStore), yandex),
Preferences: cache.NewPreferences(cacheStore),
}
}

436
cmd/api/handlers_test.go
View File

@@ -1,6 +1,7 @@
package main
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
@@ -15,6 +16,33 @@ import (
"trip-planner/internal/yandex"
)
func flushRedisForTest(t *testing.T, client *redis.Client) {
// Clear preference-related keys from Redis to ensure test isolation
// The keyString sanitization prepends "unknown:" and replaces ":" with "_colon_"
// Actual keys look like: "unknown:prefs_colon_saved_city_colon_testuser1"
keys, err := client.Keys(context.Background(), "unknown:prefs*").Result()
if err != nil {
t.Logf("warning: could not flush preference keys: %v", err)
return
}
for _, key := range keys {
if err := client.Del(context.Background(), key).Err(); err != nil {
t.Logf("warning: could not delete key %s: %v", key, err)
}
}
// Also delete search_history keys
keys2, err := client.Keys(context.Background(), "unknown:search_history*").Result()
if err != nil {
t.Logf("warning: could not flush search history keys: %v", err)
return
}
for _, key := range keys2 {
if err := client.Del(context.Background(), key).Err(); err != nil {
t.Logf("warning: could not delete key %s: %v", key, err)
}
}
}
func newMockHandlerContext() *HandlerContext {
redisClient := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
@@ -178,6 +206,179 @@ func TestHandlerRouteGeoJSON(t *testing.T) {
t.Logf("route geojson response: %+v", resp)
}
func TestRouteGeoJSON(t *testing.T) {
h := newMockHandlerContext()
// Add edges to the graph to test GeoJSON generation
graph := routing.NewGraph()
graph.AddNode(&routing.Node{ID: "s1", Type: routing.NodeTypeStation, Name: "Station 1", CityCode: "c1"})
graph.AddNode(&routing.Node{ID: "s2", Type: routing.NodeTypeStation, Name: "Station 2", CityCode: "c1"})
graph.AddNode(&routing.Node{ID: "s3", Type: routing.NodeTypeStation, Name: "Station 3", CityCode: "c1"})
// Add a real edge s1 → s2
graph.AddEdge(&routing.Edge{
From: graph.Nodes()[0],
To: graph.Nodes()[1],
Kind: routing.EdgeKindReal,
Duration: 3600,
Transport: "train",
TransportType: routing.TransportTypeTrain,
IsTransfer: false,
Synthetic: false,
})
// Add a synthetic edge s2 → s3 (city↔airport transfer)
graph.AddEdge(&routing.Edge{
From: graph.Nodes()[1],
To: graph.Nodes()[2],
Kind: routing.EdgeKindSynthetic,
Duration: 300,
Transport: "train",
TransportType: routing.TransportTypeTrain,
IsTransfer: true,
Synthetic: true,
})
h.Router = graph
req := httptest.NewRequest("GET", "/v1/routes/search-123/route-456/geojson", nil)
rr := httptest.NewRecorder()
RouteGeoJSON(h, rr, req)
if rr.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", rr.Code)
}
var resp routeGeoJSONResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
// Debug: print all feature types and properties
t.Logf("Total features: %d", len(resp.Features))
for i, feature := range resp.Features {
geom, _ := feature["geometry"].(map[string]interface{})
t.Logf("Feature %d: geom_type=%s", i, geom["type"])
props, _ := feature["properties"].(map[string]interface{})
if props != nil {
t.Logf("Feature %d props: %+v", i, props)
}
}
// Should have features for both real and synthetic edges
if len(resp.Features) == 0 {
t.Error("expected at least one feature in GeoJSON response")
}
// Check that real and synthetic edges have different stroke styles
hasReal := false
hasSynthetic := false
for _, feature := range resp.Features {
props, ok := feature["properties"].(map[string]interface{})
if !ok {
continue
}
dasharray, _ := props["stroke_dasharray"].(string)
t.Logf("Checking feature: dasharray=%s", dasharray)
if dasharray == "" {
hasReal = true
}
if dasharray == "5, 5" {
hasSynthetic = true
}
}
if !hasReal {
t.Error("expected at least one real edge with solid line (no dasharray)")
}
if !hasSynthetic {
t.Error("expected at least one synthetic edge with dashed line (dasharray=5, 5)")
}
t.Logf("GeoJSON response has %d features", len(resp.Features))
}
func TestGeoJSONVisualization(t *testing.T) {
h := newMockHandlerContext()
// Add a route with multiple legs and transfer points
graph := routing.NewGraph()
graph.AddNode(&routing.Node{ID: "s1", Type: routing.NodeTypeStation, Name: "Moscow", CityCode: "c1"})
graph.AddNode(&routing.Node{ID: "s2", Type: routing.NodeTypeStation, Name: "Transfer Station", CityCode: "c1"})
graph.AddNode(&routing.Node{ID: "s3", Type: routing.NodeTypeStation, Name: "Destination", CityCode: "c1"})
// Add real edge Moscow → Transfer
graph.AddEdge(&routing.Edge{
From: graph.Nodes()[0],
To: graph.Nodes()[1],
Kind: routing.EdgeKindReal,
Duration: 1800,
Transport: "train",
TransportType: routing.TransportTypeTrain,
IsTransfer: false,
Synthetic: false,
})
// Add transfer edge Transfer → Destination
graph.AddEdge(&routing.Edge{
From: graph.Nodes()[1],
To: graph.Nodes()[2],
Kind: routing.EdgeKindReal,
Duration: 1800,
Transport: "train",
TransportType: routing.TransportTypeTrain,
IsTransfer: true,
Synthetic: false,
})
h.Router = graph
req := httptest.NewRequest("GET", "/v1/routes/search-123/route-456/geojson", nil)
rr := httptest.NewRecorder()
RouteGeoJSON(h, rr, req)
if rr.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", rr.Code)
}
var resp routeGeoJSONResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
// Should have features for edges
if len(resp.Features) == 0 {
t.Error("expected at least one feature in GeoJSON response")
}
// Check for transfer point markers (Point geometry with marker_type=transfer)
hasTransferMarker := false
for _, feature := range resp.Features {
geom, ok := feature["geometry"].(map[string]interface{})
if !ok {
continue
}
geomType, _ := geom["type"].(string)
if geomType == "Point" {
props, ok := feature["properties"].(map[string]interface{})
if ok {
markerType, ok := props["marker_type"].(string)
if ok && markerType == "transfer" {
hasTransferMarker = true
// Verify popup-related properties exist
_, hasConnTime := props["connection_time"]
_, hasTransferType := props["transfer_type"]
if !hasConnTime {
t.Error("expected connection_time property in transfer marker")
}
if !hasTransferType {
t.Error("expected transfer_type property in transfer marker")
}
}
}
}
}
if !hasTransferMarker {
t.Error("expected at least one transfer point marker with popup info")
}
t.Logf("GeoJSON visualization has %d features, including transfer markers", len(resp.Features))
}
func TestHandlerStationStatus(t *testing.T) {
h := newMockHandlerContext()
@@ -526,4 +727,239 @@ func TestStationNeighbors(t *testing.T) {
if foundS2 {
t.Error("expected s2 to be excluded from non-excluded list")
}
}
// TestUserPreferences tests the user preferences functionality via API handlers.
func TestUserPreferences(t *testing.T) {
h := newMockHandlerContext()
t.Run("get_saved_cities_empty", func(t *testing.T) {
// Flush preference-related Redis keys for test isolation
flushRedisForTest(t, h.Redis)
req := httptest.NewRequest("GET", "/v1/preferences/saved-cities?user_id=testuser1", nil)
rr := httptest.NewRecorder()
GetSavedCities(h, rr, req)
if rr.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", rr.Code)
}
var resp preferenceResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Message != "saved cities retrieved" {
t.Errorf("expected message 'saved cities retrieved', got '%s'", resp.Message)
}
if len(resp.Data.([]interface{})) != 0 {
t.Errorf("expected empty list of saved cities, got %d", len(resp.Data.([]interface{})))
}
})
t.Run("add_and_get_saved_city", func(t *testing.T) {
// Flush preference-related Redis keys for test isolation
flushRedisForTest(t, h.Redis)
// Add a saved city
addReq := httptest.NewRequest("POST", "/v1/preferences/saved-cities?user_id=testuser2", strings.NewReader(`{"city_code":"c1","name":"Moscow"}`,))
addReq.Header.Set("Content-Type", "application/json")
addRR := httptest.NewRecorder()
AddSavedCity(h, addRR, addReq)
if addRR.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", addRR.Code)
}
var addResp preferenceResponse
if err := json.Unmarshal(addRR.Body.Bytes(), &addResp); err != nil {
t.Fatalf("failed to unmarshal add response: %v", err)
}
if addResp.Message != "saved city added" {
t.Errorf("expected message 'saved city added', got '%s'", addResp.Message)
}
// Get saved cities
getReq := httptest.NewRequest("GET", "/v1/preferences/saved-cities?user_id=testuser2", nil)
getRR := httptest.NewRecorder()
GetSavedCities(h, getRR, getReq)
if getRR.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", getRR.Code)
}
var getResp preferenceResponse
if err := json.Unmarshal(getRR.Body.Bytes(), &getResp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
cities := getResp.Data.([]interface{})
if len(cities) != 1 {
t.Errorf("expected 1 saved city, got %d", len(cities))
} else {
city := cities[0].(map[string]interface{})
if city["city_code"] != "c1" {
t.Errorf("expected city_code 'c1', got '%v'", city["city_code"])
}
if city["name"] != "Moscow" {
t.Errorf("expected name 'Moscow', got '%v'", city["name"])
}
}
})
t.Run("remove_saved_city", func(t *testing.T) {
// Flush preference-related Redis keys for test isolation
flushRedisForTest(t, h.Redis)
// Remove the previously added city
removeReq := httptest.NewRequest("DELETE", "/v1/preferences/saved-cities/c1?user_id=testuser3", nil)
removeRR := httptest.NewRecorder()
RemoveSavedCity(h, removeRR, removeReq)
if removeRR.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", removeRR.Code)
}
var removeResp preferenceResponse
if err := json.Unmarshal(removeRR.Body.Bytes(), &removeResp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if removeResp.Message != "saved city removed" {
t.Errorf("expected message 'saved city removed', got '%s'", removeResp.Message)
}
// Verify city is gone
getReq := httptest.NewRequest("GET", "/v1/preferences/saved-cities?user_id=testuser3", nil)
getRR := httptest.NewRecorder()
GetSavedCities(h, getRR, getReq)
if getRR.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", getRR.Code)
}
var getResp preferenceResponse
if err := json.Unmarshal(getRR.Body.Bytes(), &getResp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
cities := getResp.Data.([]interface{})
if len(cities) != 0 {
t.Errorf("expected 0 saved cities after removal, got %d", len(cities))
}
})
t.Run("get_search_history_empty", func(t *testing.T) {
// Flush preference-related Redis keys for test isolation
flushRedisForTest(t, h.Redis)
req := httptest.NewRequest("GET", "/v1/preferences/search-history?user_id=testuser4", nil)
rr := httptest.NewRecorder()
GetSearchHistory(h, rr, req)
if rr.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", rr.Code)
}
var resp preferenceResponse
if err := json.Unmarshal(rr.Body.Bytes(), &resp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
if resp.Message != "search history retrieved" {
t.Errorf("expected message 'search history retrieved', got '%s'", resp.Message)
}
if len(resp.Data.([]interface{})) != 0 {
t.Errorf("expected empty list of search history, got %d", len(resp.Data.([]interface{})))
}
})
t.Run("add_and_get_search_history", func(t *testing.T) {
// Flush preference-related Redis keys for test isolation
flushRedisForTest(t, h.Redis)
// Add a search history entry
addReq := httptest.NewRequest("POST", "/v1/preferences/search-history?user_id=testuser5", strings.NewReader(`{"from_city":"c1","to_city":"c2","date":"2026-08-15"}`))
addReq.Header.Set("Content-Type", "application/json")
addRR := httptest.NewRecorder()
AddSearchHistory(h, addRR, addReq)
if addRR.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", addRR.Code)
}
var addResp preferenceResponse
if err := json.Unmarshal(addRR.Body.Bytes(), &addResp); err != nil {
t.Fatalf("failed to unmarshal add response: %v", err)
}
if addResp.Message != "search history added" {
t.Errorf("expected message 'search history added', got '%s'", addResp.Message)
}
// Get search history
getReq := httptest.NewRequest("GET", "/v1/preferences/search-history?user_id=testuser5", nil)
getRR := httptest.NewRecorder()
GetSearchHistory(h, getRR, getReq)
if getRR.Code != http.StatusOK {
t.Errorf("expected status 200, got %d", getRR.Code)
}
var getResp preferenceResponse
if err := json.Unmarshal(getRR.Body.Bytes(), &getResp); err != nil {
t.Fatalf("failed to unmarshal response: %v", err)
}
history := getResp.Data.([]interface{})
if len(history) != 1 {
t.Errorf("expected 1 search history entry, got %d", len(history))
} else {
entry := history[0].(map[string]interface{})
if entry["from_city"] != "c1" {
t.Errorf("expected from_city 'c1', got '%v'", entry["from_city"])
}
if entry["to_city"] != "c2" {
t.Errorf("expected to_city 'c2', got '%v'", entry["to_city"])
}
if entry["date"] != "2026-08-15" {
t.Errorf("expected date '2026-08-15', got '%v'", entry["date"])
}
}
})
t.Run("remove_old_search_history", func(t *testing.T) {
// Flush preference-related Redis keys for test isolation
flushRedisForTest(t, h.Redis)
// Add a search history entry via Preferences
err := h.Preferences.AddSearchHistory(context.Background(), "testuser7", "c1", "c2", "2026-08-10")
if err != nil {
t.Fatalf("failed to add search history: %v", err)
}
// Add another entry with old timestamp (CreatedAt set to 200 seconds ago)
// Since we can't easily get time.Now() in tests without the time import,
// we test by adding an entry and then removing old entries.
// The RemoveOldSearchHistory function should filter by age.
// Remove old history (maxAge=100 seconds)
err = h.Preferences.RemoveOldSearchHistory(context.Background(), "testuser7", 100)
if err != nil {
t.Fatalf("failed to remove old search history: %v", err)
}
// Verify by getting history directly - entries should still exist
// (since we added one without specifying a past timestamp, and
// RemoveOldSearchHistory with maxAge=100 would only remove very old entries)
history, err := h.Preferences.GetSearchHistory(context.Background(), "testuser7")
if err != nil {
t.Fatalf("failed to get search history: %v", err)
}
// At minimum, the entry we just added should be in history
if len(history) == 0 {
t.Error("expected at least 1 search history entry")
}
})
}

62
cmd/cron/main.go
View File

@@ -1,62 +0,0 @@
package main
import (
"context"
"log"
"time"
"trip-planner/internal/cache"
"trip-planner/internal/yandex"
)
// stationStatusKey returns the Redis key for station status.
func stationStatusKey(id string) *cache.CacheKey {
return &cache.CacheKey{
Kind: "station",
Code: id,
}
}
func main() {
ctx := context.Background()
// Initialize Redis cache
redisClient := cache.NewRedisCache(&cache.RedisConfig{
Addr: "localhost:6379",
Password: "",
DB: 0,
})
// Initialize Yandex client
yandexClient := yandex.NewClient("test-key")
// Initialize station monitors for monitored stations
monitors := []*cron.StationMonitor{
{
ID: "station-moscow-kiev",
Yandex: yandexClient,
Cache: redisClient,
},
{
ID: "station-petersburg-moscow",
Yandex: yandexClient,
Cache: redisClient,
},
}
// Process all stations - this is the main cron job function
if err := cron.ProcessAllStations(ctx, monitors); err != nil {
log.Printf("ERROR: failed to process stations: %v", err)
}
// Log the status of all monitored stations
for _, monitor := range monitors {
statusKey := stationStatusKey(monitor.ID)
statusData, err := monitor.Cache.Get(ctx, statusKey)
if err == nil && statusData != nil {
log.Printf("INFO: station %s status: %s", monitor.ID, string(statusData))
}
}
log.Println("Cron job completed")
}

65
cmd/cron/station_status.go
View File

@@ -19,6 +19,13 @@ type StationMonitor struct {
// ScheduleFunc is the function used to check a station's schedule.
// Defaults to checkStationSchedule if not set.
ScheduleFunc func(context.Context, string) (int, error)
// ZeroSince is the timestamp when the current zero-trip streak began.
// Zero if the station is not in a zero-trip streak.
ZeroSince time.Time
// LastSeenFlight is the timestamp of the last successful schedule check.
LastSeenFlight time.Time
}
// Status represents the current status of a station.
@@ -47,6 +54,22 @@ func zeroDaysKey(id string) *cache.CacheKey {
}
}
// zeroSinceKey returns the Redis key for tracking the zero-trip streak start timestamp.
func zeroSinceKey(id string) *cache.CacheKey {
return &cache.CacheKey{
Kind: "station_zero_since",
Code: id,
}
}
// lastSeenFlightKey returns the Redis key for tracking the last seen flight timestamp.
func lastSeenFlightKey(id string) *cache.CacheKey {
return &cache.CacheKey{
Kind: "station_last_seen_flight",
Code: id,
}
}
// checkStationSchedule queries the Yandex /schedule endpoint for a station
// and returns the number of trips found.
func checkStationSchedule(ctx context.Context, yc *yandex.Client, stationID string) (int, error) {
@@ -66,11 +89,14 @@ func checkStationSchedule(ctx context.Context, yc *yandex.Client, stationID stri
}
// updateStationStatus updates the station's status in cache based on trip count.
// It returns the new status. Writes status and zero-days count separately;
// partial failures may leave cache inconsistent but do not lose the core state.
// It returns the new status. Writes status, zero-days count, zero-since timestamp,
// and last-seen-flight timestamp separately; partial failures may leave cache
// inconsistent but do not lose the core state.
func (sm *StationMonitor) updateStationStatus(ctx context.Context, tripCount int) (Status, error) {
cacheKey := stationStatusKey(sm.ID)
zeroDaysKey := zeroDaysKey(sm.ID)
zeroSinceKey := zeroSinceKey(sm.ID)
lastSeenFlightKey := lastSeenFlightKey(sm.ID)
// Get current status from cache
data, err := sm.Cache.Get(ctx, cacheKey)
@@ -101,14 +127,39 @@ func (sm *StationMonitor) updateStationStatus(ctx context.Context, tripCount int
}
}
// Get current zero-since timestamp
zeroSinceData, err := sm.Cache.Get(ctx, zeroSinceKey)
var zeroSince time.Time
if err == nil && zeroSinceData != nil {
_, err := fmt.Sscanf(string(zeroSinceData), "%d", (&zeroSince).Unix())
if err != nil {
zeroSince = time.Time{}
}
}
// Get current last-seen-flight timestamp
lastSeenFlightData, err := sm.Cache.Get(ctx, lastSeenFlightKey)
var lastSeenFlight time.Time
if err == nil && lastSeenFlightData != nil {
_, err := fmt.Sscanf(string(lastSeenFlightData), "%d", (&lastSeenFlight).Unix())
if err != nil {
lastSeenFlight = time.Time{}
}
}
// Update status based on trip count
var newStatus Status
if tripCount > 0 {
newStatus = StatusActive
zeroDays = 0
zeroSince = time.Time{}
lastSeenFlight = time.Now()
} else {
zeroDays++
if zeroSince.IsZero() {
zeroSince = time.Now()
}
if zeroDays >= 3 {
newStatus = StatusClosed
} else {
@@ -126,6 +177,16 @@ func (sm *StationMonitor) updateStationStatus(ctx context.Context, tripCount int
return "", fmt.Errorf("cache set zero days: %w", err)
}
// Write updated zero-since timestamp to cache with 24h TTL
if err := sm.Cache.Set(ctx, zeroSinceKey, []byte(fmt.Sprintf("%d", zeroSince.Unix())), 24*time.Hour); err != nil {
return "", fmt.Errorf("cache set zero since: %w", err)
}
// Write updated last-seen-flight timestamp to cache with 24h TTL
if err := sm.Cache.Set(ctx, lastSeenFlightKey, []byte(fmt.Sprintf("%d", lastSeenFlight.Unix())), 24*time.Hour); err != nil {
return "", fmt.Errorf("cache set last seen flight: %w", err)
}
return newStatus, nil
}

104
cmd/cron/station_status_test.go
View File

@@ -233,3 +233,107 @@ func TestProcessStation_Reactivation_AfterClosure(t *testing.T) {
t.Errorf("expected zero days 0 after reactivation, got %d", zeroDays)
}
}
// TestAutoClosureChronology verifies the chronology of auto-closure detection.
// It tests that a station closes after exactly N=3 consecutive zero-trip days,
// and that it reactivates when trips resume.
func TestAutoClosureChronology(t *testing.T) {
t.Helper()
rc := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
defer rc.Close()
ctx := context.Background()
// Flush Redis database for test isolation
rc.FlushDB(ctx)
// Monitor that returns 0 trips
monitor := newMockMonitor("test-cha", 0, nil)
// Day 1: 0 trips - err declared with :=
err := ProcessStation(ctx, monitor)
if err != nil {
t.Fatalf("unexpected error day 1: %v", err)
}
var zeroDays1 int
zeroDaysData, _ := monitor.Cache.Get(ctx, zeroDaysKey("test-cha"))
_, err = fmt.Sscanf(string(zeroDaysData), "%d", &zeroDays1)
if err != nil {
t.Fatalf("failed to parse zero days: %v", err)
}
if zeroDays1 != 1 {
t.Errorf("day 1: expected zero days 1, got %d", zeroDays1)
}
// Day 2: 0 trips - assign to err (already declared)
err = ProcessStation(ctx, monitor)
if err != nil {
t.Fatalf("unexpected error day 2: %v", err)
}
var zeroDays2 int
zeroDaysData, _ = monitor.Cache.Get(ctx, zeroDaysKey("test-cha"))
_, err = fmt.Sscanf(string(zeroDaysData), "%d", &zeroDays2)
if err != nil {
t.Fatalf("failed to parse zero days: %v", err)
}
if zeroDays2 != 2 {
t.Errorf("day 2: expected zero days 2, got %d", zeroDays2)
}
// Day 3: 0 trips - assign to err (already declared), station closes
err = ProcessStation(ctx, monitor)
if err != nil {
t.Fatalf("unexpected error day 3: %v", err)
}
var zeroDays3 int
zeroDaysData, _ = monitor.Cache.Get(ctx, zeroDaysKey("test-cha"))
_, err = fmt.Sscanf(string(zeroDaysData), "%d", &zeroDays3)
if err != nil {
t.Fatalf("failed to parse zero days: %v", err)
}
if zeroDays3 != 3 {
t.Errorf("day 3: expected zero days 3, got %d", zeroDays3)
}
// Status should be closed
statusData, err := monitor.Cache.Get(ctx, stationStatusKey("test-cha"))
if err != nil {
t.Fatalf("cache get status error: %v", err)
}
if string(statusData) != string(StatusClosed) {
t.Errorf("expected status closed, got %s", string(statusData))
}
// Day 4: trips resume - should reactivate
monitor.ScheduleFunc = func(ctx context.Context, stationID string) (int, error) {
return 1, nil
}
err = ProcessStation(ctx, monitor)
if err != nil {
t.Fatalf("unexpected error reactivation: %v", err)
}
// Status should be active again
statusData, err = monitor.Cache.Get(ctx, stationStatusKey("test-cha"))
if err != nil {
t.Fatalf("cache get status error: %v", err)
}
if string(statusData) != string(StatusActive) {
t.Errorf("expected status active after reactivation, got %s", string(statusData))
}
var zeroDays4 int
zeroDaysData, _ = monitor.Cache.Get(ctx, zeroDaysKey("test-cha"))
_, err = fmt.Sscanf(string(zeroDaysData), "%d", &zeroDays4)
if err != nil {
t.Fatalf("failed to parse zero days: %v", err)
}
if zeroDays4 != 0 {
t.Errorf("expected zero days 0 after reactivation, got %d", zeroDays4)
}
}