Eric Rakestraw
0d82e5d60e
All checks were successful
ci/woodpecker/push/build-image Pipeline was successful
302 lines
9.4 KiB
Go
302 lines
9.4 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/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.ObservationSummaryMetric
|
|
conditions []ports.ObservationConditionMetric
|
|
precip []string
|
|
summaryWin time.Duration
|
|
conditionsWin time.Duration
|
|
precipWin time.Duration
|
|
}
|
|
|
|
func (f *fakeObservationRepo) GetCurrentSummary(_ context.Context, window time.Duration) (ports.ObservationSummaryMetric, error) {
|
|
f.summaryWin = 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
|
|
}
|
|
|
|
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 TestForecastInvalidTimestampReturns400(t *testing.T) {
|
|
fcRepo := &fakeForecastRepo{}
|
|
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=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 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")
|
|
}
|
|
|
|
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 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) {
|
|
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,
|
|
},
|
|
},
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
var payload map[string]any
|
|
if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
|
|
t.Fatalf("decode response: %v", err)
|
|
}
|
|
|
|
periods := payload["periods"].([]any)
|
|
first := periods[0].(map[string]any)
|
|
if got := first["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 {
|
|
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 := first["windSpeedKmh"]; exists {
|
|
t.Fatalf("did not expect metric key windSpeedKmh in US 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")
|
|
}
|
|
}
|
|
|
|
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")
|
|
}
|
|
|
|
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")
|
|
}
|
|
}
|