Added a /conditions/current endpoint with computed best-guess values for current conditions

internal/adapters/httpapi/server.go

@@ -3,21 +3,30 @@ package httpapi
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"net/http"
+	"strconv"
+	"strings"
 	"time"
 
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/alerts"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/conditions"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/forecasts"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/observations"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/platform/constants"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/platform/timeparse"
 )
 
 type ObservationService interface {
-	GetCurrent(ctx context.Context) (observations.CurrentResponse, error)
+	GetRecent(ctx context.Context, count int, unitSystem string) (observations.Response, error)
+}
+
+type ConditionsService interface {
+	GetCurrent(ctx context.Context, unitSystem string) (conditions.Response, error)
 }
 
 type ForecastService interface {
-	GetByTimestamp(ctx context.Context, ts time.Time) (forecasts.Response, error)
+	GetByTimestamp(ctx context.Context, ts time.Time, unitSystem string) (forecasts.Response, error)
 }
 
 type AlertService interface {
@@ -25,32 +34,67 @@ type AlertService interface {
 }
 
 type Server struct {
-	obsSvc    ObservationService
-	fcSvc     ForecastService
-	alertsSvc AlertService
+	obsSvc        ObservationService
+	conditionsSvc ConditionsService
+	fcSvc         ForecastService
+	alertsSvc     AlertService
 }
 
-func NewServer(obsSvc ObservationService, fcSvc ForecastService, alertsSvc AlertService) *Server {
-	return &Server{obsSvc: obsSvc, fcSvc: fcSvc, alertsSvc: alertsSvc}
+func NewServer(obsSvc ObservationService, conditionsSvc ConditionsService, fcSvc ForecastService, alertsSvc AlertService) *Server {
+	return &Server{obsSvc: obsSvc, conditionsSvc: conditionsSvc, fcSvc: fcSvc, alertsSvc: alertsSvc}
 }
 
 func (s *Server) Handler() http.Handler {
 	mux := http.NewServeMux()
-	mux.HandleFunc("/observations/current", s.handleObservationsCurrent)
+	mux.HandleFunc("/observations", s.handleObservations)
+	mux.HandleFunc("/conditions/current", s.handleConditionsCurrent)
 	mux.HandleFunc("/forecast", s.handleForecast)
 	mux.HandleFunc("/alerts/current", s.handleAlertsCurrent)
 	return mux
 }
 
-func (s *Server) handleObservationsCurrent(w http.ResponseWriter, r *http.Request) {
+func (s *Server) handleConditionsCurrent(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		writeError(w, http.StatusMethodNotAllowed, "method_not_allowed", "only GET is supported")
 		return
 	}
 
-	resp, err := s.obsSvc.GetCurrent(r.Context())
+	unitSystem, err := parseUnits(r, constants.UnitSystemUS)
 	if err != nil {
-		writeError(w, http.StatusInternalServerError, "internal_error", "failed to fetch current observations")
+		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
+		return
+	}
+
+	resp, err := s.conditionsSvc.GetCurrent(r.Context(), unitSystem)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "internal_error", "failed to fetch current conditions")
+		return
+	}
+
+	writeJSON(w, http.StatusOK, resp)
+}
+
+func (s *Server) handleObservations(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeError(w, http.StatusMethodNotAllowed, "method_not_allowed", "only GET is supported")
+		return
+	}
+
+	unitSystem, err := parseUnits(r, constants.UnitSystemMetric)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
+		return
+	}
+
+	count, err := parseCount(r)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
+		return
+	}
+
+	resp, err := s.obsSvc.GetRecent(r.Context(), count, unitSystem)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, "internal_error", "failed to fetch observations")
 		return
 	}
 
@@ -63,6 +107,12 @@ func (s *Server) handleForecast(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	unitSystem, err := parseUnits(r, constants.UnitSystemUS)
+	if err != nil {
+		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
+		return
+	}
+
 	raw := r.URL.Query().Get("timestamp")
 	ts, err := timeparse.ParseTimestamp(raw)
 	if err != nil {
@@ -70,7 +120,7 @@ func (s *Server) handleForecast(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	resp, err := s.fcSvc.GetByTimestamp(r.Context(), ts)
+	resp, err := s.fcSvc.GetByTimestamp(r.Context(), ts, unitSystem)
 	if err != nil {
 		writeError(w, http.StatusInternalServerError, "internal_error", "failed to fetch forecast")
 		return
@@ -94,6 +144,35 @@ func (s *Server) handleAlertsCurrent(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, resp)
 }
 
+func parseCount(r *http.Request) (int, error) {
+	raw := strings.TrimSpace(r.URL.Query().Get("count"))
+	if raw == "" {
+		return constants.DefaultObservationCount, nil
+	}
+
+	count, err := strconv.Atoi(raw)
+	if err != nil {
+		return 0, fmt.Errorf("count must be an integer between 1 and %d", constants.MaxObservationCount)
+	}
+	if count < 1 || count > constants.MaxObservationCount {
+		return 0, fmt.Errorf("count must be an integer between 1 and %d", constants.MaxObservationCount)
+	}
+	return count, nil
+}
+
+func parseUnits(r *http.Request, defaultSystem string) (string, error) {
+	raw := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("units")))
+	if raw == "" {
+		return defaultSystem, nil
+	}
+	switch raw {
+	case constants.UnitSystemUS, constants.UnitSystemMetric:
+		return raw, nil
+	default:
+		return "", fmt.Errorf("units must be one of: us, metric")
+	}
+}
+
 type errorResponse struct {
 	Code    string `json:"code"`
 	Message string `json:"message"`

internal/adapters/httpapi/server_test.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/alerts"
+	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/conditions"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/forecasts"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/observations"
 	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/units"
@@ -17,27 +18,21 @@ import (
 )
 
 type fakeObservationRepo struct {
-	summary       ports.ObservationSummaryMetric
-	conditions    []ports.ObservationConditionMetric
-	precip        []string
-	summaryWin    time.Duration
-	conditionsWin time.Duration
-	precipWin     time.Duration
+	summary       ports.ObservationCurrentConditionsMetric
+	summaryWindow time.Duration
+
+	observations []ports.ObservationRecordMetric
+	recentCount  int
 }
 
-func (f *fakeObservationRepo) GetCurrentSummary(_ context.Context, window time.Duration) (ports.ObservationSummaryMetric, error) {
-	f.summaryWin = window
+func (f *fakeObservationRepo) GetCurrentConditionsSummary(_ context.Context, window time.Duration) (ports.ObservationCurrentConditionsMetric, error) {
+	f.summaryWindow = window
 	return f.summary, nil
 }
 
-func (f *fakeObservationRepo) ListCurrentConditions(_ context.Context, window time.Duration) ([]ports.ObservationConditionMetric, error) {
-	f.conditionsWin = window
-	return f.conditions, nil
-}
-
-func (f *fakeObservationRepo) ListCurrentPrecipitationEvents(_ context.Context, window time.Duration) ([]string, error) {
-	f.precipWin = window
-	return f.precip, nil
+func (f *fakeObservationRepo) ListRecentObservations(_ context.Context, count int) ([]ports.ObservationRecordMetric, error) {
+	f.recentCount = count
+	return f.observations, nil
 }
 
 type fakeForecastRepo struct {
@@ -58,15 +53,349 @@ func (fakeAlertRepo) ListCurrentAlerts(context.Context) ([]ports.AlertRecord, er
 	return nil, nil
 }
 
-func TestForecastInvalidTimestampReturns400(t *testing.T) {
-	fcRepo := &fakeForecastRepo{}
-	obsRepo := &fakeObservationRepo{}
+func newTestUnitRegistry(t *testing.T) *units.Registry {
+	t.Helper()
 
-	server := NewServer(
-		observations.NewService(obsRepo, units.USConverter{}, constants.ObservationWindow),
-		forecasts.NewService(fcRepo, units.USConverter{}, constants.ForecastQueryLimit),
+	reg := units.NewRegistry()
+	if err := reg.Register(units.StaticFactory{UnitSystem: constants.UnitSystemUS, Converter: units.USConverter{}}); err != nil {
+		t.Fatalf("register us converter: %v", err)
+	}
+	if err := reg.Register(units.StaticFactory{UnitSystem: constants.UnitSystemMetric, Converter: units.MetricConverter{}}); err != nil {
+		t.Fatalf("register metric converter: %v", err)
+	}
+	return reg
+}
+
+func newTestHandler(t *testing.T, obsRepo *fakeObservationRepo, fcRepo *fakeForecastRepo) http.Handler {
+	t.Helper()
+
+	reg := newTestUnitRegistry(t)
+	return NewServer(
+		observations.NewService(obsRepo, reg),
+		conditions.NewService(obsRepo, reg, constants.ObservationWindow),
+		forecasts.NewService(fcRepo, reg, constants.ForecastQueryLimit),
 		alerts.NewService(fakeAlertRepo{}),
 	).Handler()
+}
+
+func TestLegacyObservationsCurrentPathRemoved(t *testing.T) {
+	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations/current", nil))
+	if w.Code != http.StatusNotFound {
+		t.Fatalf("expected 404 for removed /observations/current, got %d", w.Code)
+	}
+}
+
+func TestConditionsCurrentDefaultsToUSUnits(t *testing.T) {
+	tempC := 20.0
+	appTempC := 15.0
+	dewpointC := 10.0
+	relHumidity := 81.0
+	windKmh := 10.0
+	windDir := 270.0
+	conditionCode := 63
+	isDay := true
+
+	obsRepo := &fakeObservationRepo{
+		summary: ports.ObservationCurrentConditionsMetric{
+			TemperatureC:         &tempC,
+			ApparentTemperatureC: &appTempC,
+			DewpointC:            &dewpointC,
+			RelativeHumidity:     &relHumidity,
+			WindSpeedKmh:         &windKmh,
+			WindDirectionDegrees: &windDir,
+			ConditionCode:        &conditionCode,
+			IsDay:                &isDay,
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got := payload["temperatureF"].(float64); got != 68.0 {
+		t.Fatalf("expected temperatureF=68.0, got %v", got)
+	}
+	if got := payload["apparentTemperatureF"].(float64); got != 59.0 {
+		t.Fatalf("expected apparentTemperatureF=59.0, got %v", got)
+	}
+	if got := payload["dewpointF"].(float64); got != 50.0 {
+		t.Fatalf("expected dewpointF=50.0, got %v", got)
+	}
+	if got := payload["windSpeedMph"].(float64); got != 6.2 {
+		t.Fatalf("expected windSpeedMph=6.2, got %v", got)
+	}
+	if got := payload["relativeHumidityPercent"].(float64); got != 81.0 {
+		t.Fatalf("expected relativeHumidityPercent=81.0, got %v", got)
+	}
+	if got := payload["windDirectionDegrees"].(float64); got != 270.0 {
+		t.Fatalf("expected windDirectionDegrees=270.0, got %v", got)
+	}
+	if got := payload["conditionCode"].(float64); got != 63 {
+		t.Fatalf("expected conditionCode=63, got %v", got)
+	}
+	if got := payload["conditionText"].(string); got != "Rain" {
+		t.Fatalf("expected conditionText=Rain, got %v", got)
+	}
+	if got := payload["isDay"].(bool); !got {
+		t.Fatalf("expected isDay=true, got %v", got)
+	}
+	if _, exists := payload["temperatureC"]; exists {
+		t.Fatalf("did not expect metric key temperatureC in default US response")
+	}
+
+	if obsRepo.summaryWindow != constants.ObservationWindow {
+		t.Fatalf("expected observation window %s, got %s", constants.ObservationWindow, obsRepo.summaryWindow)
+	}
+}
+
+func TestConditionsCurrentSupportsMetricUnits(t *testing.T) {
+	tempC := 20.0
+	windKmh := 10.0
+	conditionCode := 63
+	isDay := false
+	obsRepo := &fakeObservationRepo{
+		summary: ports.ObservationCurrentConditionsMetric{
+			TemperatureC:  &tempC,
+			WindSpeedKmh:  &windKmh,
+			ConditionCode: &conditionCode,
+			IsDay:         &isDay,
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current?units=metric", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got := payload["temperatureC"].(float64); got != 20.0 {
+		t.Fatalf("expected temperatureC=20.0, got %v", got)
+	}
+	if got := payload["windSpeedKmh"].(float64); got != 10.0 {
+		t.Fatalf("expected windSpeedKmh=10.0, got %v", got)
+	}
+	if got := payload["conditionCode"].(float64); got != 63 {
+		t.Fatalf("expected conditionCode=63, got %v", got)
+	}
+	if got := payload["conditionText"].(string); got != "Rain" {
+		t.Fatalf("expected conditionText=Rain, got %v", got)
+	}
+	if got := payload["isDay"].(bool); got {
+		t.Fatalf("expected isDay=false, got %v", got)
+	}
+	if _, exists := payload["temperatureF"]; exists {
+		t.Fatalf("did not expect US key temperatureF in metric response")
+	}
+}
+
+func TestConditionsCurrentOmitsConditionFieldsWhenNoObservations(t *testing.T) {
+	obsRepo := &fakeObservationRepo{
+		summary: ports.ObservationCurrentConditionsMetric{},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if _, exists := payload["conditionCode"]; exists {
+		t.Fatalf("expected conditionCode omitted when no observations")
+	}
+	if _, exists := payload["conditionText"]; exists {
+		t.Fatalf("expected conditionText omitted when no observations")
+	}
+	if _, exists := payload["isDay"]; exists {
+		t.Fatalf("expected isDay omitted when no observations")
+	}
+}
+
+func TestConditionsCurrentConditionTextUsesNilDayFallback(t *testing.T) {
+	conditionCode := 0
+	obsRepo := &fakeObservationRepo{
+		summary: ports.ObservationCurrentConditionsMetric{
+			ConditionCode: &conditionCode,
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if got := payload["conditionText"].(string); got != "Sunny" {
+		t.Fatalf("expected conditionText=Sunny, got %v", got)
+	}
+	if _, exists := payload["isDay"]; exists {
+		t.Fatalf("expected isDay omitted when summary isDay is nil")
+	}
+}
+
+func TestObservationsDefaultsToMetricAndDefaultCount(t *testing.T) {
+	tempC := 10.0
+	windKmh := 16.0
+	stationID := "KSTL"
+	stationName := "St Louis"
+	textDescription := "Cloudy"
+
+	obsRepo := &fakeObservationRepo{
+		observations: []ports.ObservationRecordMetric{
+			{
+				EventID:         "evt-1",
+				StationID:       &stationID,
+				StationName:     &stationName,
+				Timestamp:       time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
+				ConditionCode:   3,
+				TextDescription: &textDescription,
+				TemperatureC:    &tempC,
+				WindSpeedKmh:    &windKmh,
+				PresentWeather:  []ports.ObservationPresentWeatherMetric{{Raw: map[string]any{"wx": "rain"}}},
+			},
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+
+	if obsRepo.recentCount != constants.DefaultObservationCount {
+		t.Fatalf("expected default count %d, got %d", constants.DefaultObservationCount, obsRepo.recentCount)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	observationsList := payload["observations"].([]any)
+	first := observationsList[0].(map[string]any)
+
+	if got := first["temperatureC"].(float64); got != 10.0 {
+		t.Fatalf("expected temperatureC=10.0, got %v", got)
+	}
+	if got := first["windSpeedKmh"].(float64); got != 16.0 {
+		t.Fatalf("expected windSpeedKmh=16.0, got %v", got)
+	}
+	if _, exists := first["temperatureF"]; exists {
+		t.Fatalf("did not expect US key temperatureF in metric response")
+	}
+	if got := first["conditionCode"].(float64); got != 3 {
+		t.Fatalf("expected conditionCode=3, got %v", got)
+	}
+
+	pw := first["presentWeather"].([]any)
+	raw := pw[0].(map[string]any)["raw"].(map[string]any)
+	if got := raw["wx"]; got != "rain" {
+		t.Fatalf("expected presentWeather raw payload preserved, got %v", got)
+	}
+}
+
+func TestObservationsSupportsUSUnitsAndCountOverride(t *testing.T) {
+	tempC := 10.0
+	windKmh := 16.09344
+	obsRepo := &fakeObservationRepo{
+		observations: []ports.ObservationRecordMetric{
+			{
+				EventID:       "evt-1",
+				Timestamp:     time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
+				ConditionCode: 1,
+				TemperatureC:  &tempC,
+				WindSpeedKmh:  &windKmh,
+			},
+		},
+	}
+	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})
+
+	w := httptest.NewRecorder()
+	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations?count=2&units=us", nil))
+	if w.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", w.Code)
+	}
+	if obsRepo.recentCount != 2 {
+		t.Fatalf("expected count override 2, got %d", obsRepo.recentCount)
+	}
+
+	var payload map[string]any
+	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	first := payload["observations"].([]any)[0].(map[string]any)
+	if got := first["temperatureF"].(float64); got != 50.0 {
+		t.Fatalf("expected temperatureF=50.0, got %v", got)
+	}
+	if got := first["windSpeedMph"].(float64); got != 10.0 {
+		t.Fatalf("expected windSpeedMph=10.0, got %v", got)
+	}
+	if _, exists := first["temperatureC"]; exists {
+		t.Fatalf("did not expect metric key temperatureC in US response")
+	}
+}
+
+func TestObservationsCountValidation(t *testing.T) {
+	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})
+
+	cases := []string{
+		"/observations?count=0",
+		"/observations?count=-1",
+		"/observations?count=abc",
+		"/observations?count=101",
+	}
+	for _, path := range cases {
+		w := httptest.NewRecorder()
+		server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil))
+		if w.Code != http.StatusBadRequest {
+			t.Fatalf("expected 400 for %s, got %d", path, w.Code)
+		}
+	}
+}
+
+func TestInvalidUnitsReturn400(t *testing.T) {
+	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})
+
+	cases := []string{
+		"/conditions/current?units=bad",
+		"/observations?units=bad",
+		"/forecast?timestamp=2026-03-17T12:30:00Z&units=bad",
+	}
+	for _, path := range cases {
+		w := httptest.NewRecorder()
+		server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil))
+		if w.Code != http.StatusBadRequest {
+			t.Fatalf("expected 400 for %s, got %d", path, w.Code)
+		}
+	}
+}
+
+func TestForecastInvalidTimestampReturns400(t *testing.T) {
+	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})
 
 	req := httptest.NewRequest(http.MethodGet, "/forecast?timestamp=bad-time", nil)
 	w := httptest.NewRecorder()
@@ -85,85 +414,7 @@ func TestForecastInvalidTimestampReturns400(t *testing.T) {
 	}
 }
 
-func TestObservationsCurrentReturnsUSUnits(t *testing.T) {
-	summaryTemp := 20.0
-	summaryAppTemp := 15.0
-	condTemp := 10.0
-	station := "KSTL"
-	text := "Cloudy"
-	providerText := "OVC"
-	conditionText := "Cloudy"
-
-	obsRepo := &fakeObservationRepo{
-		summary: ports.ObservationSummaryMetric{
-			TemperatureC:         &summaryTemp,
-			ApparentTemperatureC: &summaryAppTemp,
-		},
-		conditions: []ports.ObservationConditionMetric{
-			{
-				StationID:              &station,
-				ObservedAt:             time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
-				TemperatureC:           &condTemp,
-				TextDescription:        &text,
-				ProviderRawDescription: &providerText,
-				ConditionText:          &conditionText,
-			},
-		},
-		precip: []string{"rain"},
-	}
-
-	fcRepo := &fakeForecastRepo{}
-	server := NewServer(
-		observations.NewService(obsRepo, units.USConverter{}, constants.ObservationWindow),
-		forecasts.NewService(fcRepo, units.USConverter{}, constants.ForecastQueryLimit),
-		alerts.NewService(fakeAlertRepo{}),
-	).Handler()
-
-	req := httptest.NewRequest(http.MethodGet, "/observations/current", nil)
-	w := httptest.NewRecorder()
-	server.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", w.Code)
-	}
-
-	var payload map[string]any
-	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
-		t.Fatalf("decode response: %v", err)
-	}
-
-	summary := payload["summary"].(map[string]any)
-	if got := summary["temperatureF"].(float64); got != 68.0 {
-		t.Fatalf("expected summary temperatureF=68.0, got %v", got)
-	}
-	if got := summary["apparentTemperatureF"].(float64); got != 59.0 {
-		t.Fatalf("expected summary apparentTemperatureF=59.0, got %v", got)
-	}
-	if _, exists := summary["temperatureC"]; exists {
-		t.Fatalf("did not expect metric key temperatureC in US response")
-	}
-	if _, exists := summary["windowMinutes"]; exists {
-		t.Fatalf("did not expect deprecated key windowMinutes in observations summary")
-	}
-
-	conditions := payload["conditions"].([]any)
-	first := conditions[0].(map[string]any)
-	if got := first["temperatureF"].(float64); got != 50.0 {
-		t.Fatalf("expected conditions[0].temperatureF=50.0, got %v", got)
-	}
-	if _, exists := first["providerRawDescription"]; exists {
-		t.Fatalf("did not expect deprecated key providerRawDescription in observations condition")
-	}
-	if _, exists := first["conditionText"]; exists {
-		t.Fatalf("did not expect deprecated key conditionText in observations condition")
-	}
-
-	if obsRepo.summaryWin != constants.ObservationWindow || obsRepo.conditionsWin != constants.ObservationWindow || obsRepo.precipWin != constants.ObservationWindow {
-		t.Fatalf("expected observation window %s to be used", constants.ObservationWindow)
-	}
-}
-
-func TestForecastReturnsUSUnits(t *testing.T) {
+func TestForecastUnitSelection(t *testing.T) {
 	tempC := 0.0
 	tempMinC := -1.0
 	tempMaxC := 1.0
@@ -189,49 +440,48 @@ func TestForecastReturnsUSUnits(t *testing.T) {
 			},
 		},
 	}
+	server := newTestHandler(t, &fakeObservationRepo{}, fcRepo)
 
-	obsRepo := &fakeObservationRepo{}
-	server := NewServer(
-		observations.NewService(obsRepo, units.USConverter{}, constants.ObservationWindow),
-		forecasts.NewService(fcRepo, units.USConverter{}, constants.ForecastQueryLimit),
-		alerts.NewService(fakeAlertRepo{}),
-	).Handler()
-
-	req := httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z", nil)
-	w := httptest.NewRecorder()
-	server.ServeHTTP(w, req)
-
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected 200, got %d", w.Code)
+	wUS := httptest.NewRecorder()
+	server.ServeHTTP(wUS, httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z", nil))
+	if wUS.Code != http.StatusOK {
+		t.Fatalf("expected US forecast 200, got %d", wUS.Code)
 	}
 
-	var payload map[string]any
-	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
-		t.Fatalf("decode response: %v", err)
+	var usPayload map[string]any
+	if err := json.Unmarshal(wUS.Body.Bytes(), &usPayload); err != nil {
+		t.Fatalf("decode us forecast: %v", err)
 	}
-
-	periods := payload["periods"].([]any)
-	first := periods[0].(map[string]any)
-	if got := first["temperatureF"].(float64); got != 32.0 {
+	usPeriod := usPayload["periods"].([]any)[0].(map[string]any)
+	if got := usPeriod["temperatureF"].(float64); got != 32.0 {
 		t.Fatalf("expected temperatureF=32.0, got %v", got)
 	}
-	if got := first["temperatureFMin"].(float64); got != 30.2 {
-		t.Fatalf("expected temperatureFMin=30.2, got %v", got)
-	}
-	if got := first["temperatureFMax"].(float64); got != 33.8 {
-		t.Fatalf("expected temperatureFMax=33.8, got %v", got)
-	}
-	if got := first["apparentTemperatureF"].(float64); got != 28.4 {
-		t.Fatalf("expected apparentTemperatureF=28.4, got %v", got)
-	}
-	if got := first["windSpeedMph"].(float64); got != 6.2 {
+	if got := usPeriod["windSpeedMph"].(float64); got != 6.2 {
 		t.Fatalf("expected windSpeedMph=6.2, got %v", got)
 	}
-	if got := first["windGustMph"].(float64); got != 10.0 {
-		t.Fatalf("expected windGustMph=10.0, got %v", got)
+	if _, exists := usPeriod["temperatureC"]; exists {
+		t.Fatalf("did not expect metric key temperatureC in US response")
 	}
-	if _, exists := first["windSpeedKmh"]; exists {
-		t.Fatalf("did not expect metric key windSpeedKmh in US response")
+
+	wMetric := httptest.NewRecorder()
+	server.ServeHTTP(wMetric, httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z&units=metric", nil))
+	if wMetric.Code != http.StatusOK {
+		t.Fatalf("expected metric forecast 200, got %d", wMetric.Code)
+	}
+
+	var metricPayload map[string]any
+	if err := json.Unmarshal(wMetric.Body.Bytes(), &metricPayload); err != nil {
+		t.Fatalf("decode metric forecast: %v", err)
+	}
+	metricPeriod := metricPayload["periods"].([]any)[0].(map[string]any)
+	if got := metricPeriod["temperatureC"].(float64); got != 0.0 {
+		t.Fatalf("expected temperatureC=0.0, got %v", got)
+	}
+	if got := metricPeriod["windSpeedKmh"].(float64); got != 10.0 {
+		t.Fatalf("expected windSpeedKmh=10.0, got %v", got)
+	}
+	if _, exists := metricPeriod["temperatureF"]; exists {
+		t.Fatalf("did not expect US key temperatureF in metric response")
 	}
 
 	if fcRepo.gotLimit != constants.ForecastQueryLimit {
@@ -241,73 +491,3 @@ func TestForecastReturnsUSUnits(t *testing.T) {
 		t.Fatalf("expected forecast timestamp passed to repo")
 	}
 }
-
-func TestNullFieldsAreOmittedFromJSON(t *testing.T) {
-	obsRepo := &fakeObservationRepo{
-		summary: ports.ObservationSummaryMetric{},
-		conditions: []ports.ObservationConditionMetric{
-			{
-				ObservedAt: time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
-			},
-		},
-	}
-	fcRepo := &fakeForecastRepo{
-		periods: []ports.ForecastPeriodMetric{
-			{
-				PeriodIndex:   1,
-				StartTime:     time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
-				EndTime:       time.Date(2026, 3, 17, 13, 0, 0, 0, time.UTC),
-				ConditionCode: 1,
-			},
-		},
-	}
-
-	server := NewServer(
-		observations.NewService(obsRepo, units.USConverter{}, constants.ObservationWindow),
-		forecasts.NewService(fcRepo, units.USConverter{}, constants.ForecastQueryLimit),
-		alerts.NewService(fakeAlertRepo{}),
-	).Handler()
-
-	wObs := httptest.NewRecorder()
-	server.ServeHTTP(wObs, httptest.NewRequest(http.MethodGet, "/observations/current", nil))
-	if wObs.Code != http.StatusOK {
-		t.Fatalf("expected observations 200, got %d", wObs.Code)
-	}
-
-	var obsPayload map[string]any
-	if err := json.Unmarshal(wObs.Body.Bytes(), &obsPayload); err != nil {
-		t.Fatalf("decode observations response: %v", err)
-	}
-	summary := obsPayload["summary"].(map[string]any)
-	if _, exists := summary["temperatureF"]; exists {
-		t.Fatalf("expected summary.temperatureF to be omitted when nil")
-	}
-	if _, exists := summary["windowMinutes"]; exists {
-		t.Fatalf("expected summary.windowMinutes to be omitted")
-	}
-
-	conditions := obsPayload["conditions"].([]any)
-	firstCond := conditions[0].(map[string]any)
-	if _, exists := firstCond["temperatureF"]; exists {
-		t.Fatalf("expected conditions[0].temperatureF to be omitted when nil")
-	}
-
-	wFc := httptest.NewRecorder()
-	server.ServeHTTP(wFc, httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z", nil))
-	if wFc.Code != http.StatusOK {
-		t.Fatalf("expected forecast 200, got %d", wFc.Code)
-	}
-
-	var fcPayload map[string]any
-	if err := json.Unmarshal(wFc.Body.Bytes(), &fcPayload); err != nil {
-		t.Fatalf("decode forecast response: %v", err)
-	}
-	periods := fcPayload["periods"].([]any)
-	firstPeriod := periods[0].(map[string]any)
-	if _, exists := firstPeriod["temperatureF"]; exists {
-		t.Fatalf("expected periods[0].temperatureF to be omitted when nil")
-	}
-	if _, exists := firstPeriod["windSpeedMph"]; exists {
-		t.Fatalf("expected periods[0].windSpeedMph to be omitted when nil")
-	}
-}