Eric Rakestraw
cb316c228a
All checks were successful
ci/woodpecker/push/build-image Pipeline was successful
494 lines
16 KiB
Go
494 lines
16 KiB
Go
package httpapi
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"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"
|
|
"gitea.maximumdirect.net/ejr/weatherapi/internal/core/ports"
|
|
"gitea.maximumdirect.net/ejr/weatherapi/internal/platform/constants"
|
|
)
|
|
|
|
type fakeObservationRepo struct {
|
|
summary ports.ObservationCurrentConditionsMetric
|
|
summaryWindow time.Duration
|
|
|
|
observations []ports.ObservationRecordMetric
|
|
recentCount int
|
|
}
|
|
|
|
func (f *fakeObservationRepo) GetCurrentConditionsSummary(_ context.Context, window time.Duration) (ports.ObservationCurrentConditionsMetric, error) {
|
|
f.summaryWindow = window
|
|
return f.summary, nil
|
|
}
|
|
|
|
func (f *fakeObservationRepo) ListRecentObservations(_ context.Context, count int) ([]ports.ObservationRecordMetric, error) {
|
|
f.recentCount = count
|
|
return f.observations, nil
|
|
}
|
|
|
|
type fakeForecastRepo struct {
|
|
periods []ports.ForecastPeriodMetric
|
|
gotTS time.Time
|
|
gotLimit int
|
|
}
|
|
|
|
func (f *fakeForecastRepo) ListForecastPeriodsAt(_ context.Context, ts time.Time, limit int) ([]ports.ForecastPeriodMetric, error) {
|
|
f.gotTS = ts
|
|
f.gotLimit = limit
|
|
return f.periods, nil
|
|
}
|
|
|
|
type fakeAlertRepo struct{}
|
|
|
|
func (fakeAlertRepo) ListCurrentAlerts(context.Context) ([]ports.AlertRecord, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func newTestUnitRegistry(t *testing.T) *units.Registry {
|
|
t.Helper()
|
|
|
|
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()
|
|
server.ServeHTTP(w, req)
|
|
|
|
if w.Code != http.StatusBadRequest {
|
|
t.Fatalf("expected 400, 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 payload["code"] != "invalid_request" {
|
|
t.Fatalf("expected invalid_request code, got %v", payload["code"])
|
|
}
|
|
}
|
|
|
|
func TestForecastUnitSelection(t *testing.T) {
|
|
tempC := 0.0
|
|
tempMinC := -1.0
|
|
tempMaxC := 1.0
|
|
appTempC := -2.0
|
|
windKmh := 10.0
|
|
gustKmh := 16.09344
|
|
name := "Now"
|
|
|
|
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),
|
|
Name: &name,
|
|
ConditionCode: 1,
|
|
TemperatureC: &tempC,
|
|
TemperatureCMin: &tempMinC,
|
|
TemperatureCMax: &tempMaxC,
|
|
ApparentTemperatureC: &appTempC,
|
|
WindSpeedKmh: &windKmh,
|
|
WindGustKmh: &gustKmh,
|
|
},
|
|
},
|
|
}
|
|
server := newTestHandler(t, &fakeObservationRepo{}, fcRepo)
|
|
|
|
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 usPayload map[string]any
|
|
if err := json.Unmarshal(wUS.Body.Bytes(), &usPayload); err != nil {
|
|
t.Fatalf("decode us forecast: %v", err)
|
|
}
|
|
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 := usPeriod["windSpeedMph"].(float64); got != 6.2 {
|
|
t.Fatalf("expected windSpeedMph=6.2, got %v", got)
|
|
}
|
|
if _, exists := usPeriod["temperatureC"]; exists {
|
|
t.Fatalf("did not expect metric key temperatureC 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 {
|
|
t.Fatalf("expected forecast query limit %d, got %d", constants.ForecastQueryLimit, fcRepo.gotLimit)
|
|
}
|
|
if fcRepo.gotTS.IsZero() {
|
|
t.Fatalf("expected forecast timestamp passed to repo")
|
|
}
|
|
}
|