Eric Rakestraw
c417c892d9
All checks were successful
ci/woodpecker/push/build-image Pipeline was successful
373 lines
13 KiB
Go
373 lines
13 KiB
Go
package spc
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/ejr/feedkit/event"
|
|
spcprovider "gitea.maximumdirect.net/ejr/weatherfeeder/internal/providers/spc"
|
|
"gitea.maximumdirect.net/ejr/weatherfeeder/model"
|
|
"gitea.maximumdirect.net/ejr/weatherfeeder/standards"
|
|
)
|
|
|
|
func TestConvectiveOutlookNormalizerMatch(t *testing.T) {
|
|
n := ConvectiveOutlookNormalizer{}
|
|
if !n.Match(event.Event{Schema: standards.SchemaRawSPCConvectiveOutlookV1}) {
|
|
t.Fatalf("Match(raw SPC outlook) = false, want true")
|
|
}
|
|
if n.Match(event.Event{Schema: standards.SchemaRawNWSAlertsV1}) {
|
|
t.Fatalf("Match(raw NWS alerts) = true, want false")
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerProducesCanonicalSchemaAndMapsSample(t *testing.T) {
|
|
out, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, spcBundle(t, 38.5, -90.5)))
|
|
if err != nil {
|
|
t.Fatalf("Normalize() error = %v", err)
|
|
}
|
|
if out.Schema != standards.SchemaWeatherOutlookV1 {
|
|
t.Fatalf("Schema = %q, want %q", out.Schema, standards.SchemaWeatherOutlookV1)
|
|
}
|
|
if out.Kind != event.Kind(standards.KindOutlook) {
|
|
t.Fatalf("Kind = %q, want outlook", out.Kind)
|
|
}
|
|
|
|
run, ok := out.Payload.(model.WeatherOutlookRun)
|
|
if !ok {
|
|
t.Fatalf("Payload type = %T, want model.WeatherOutlookRun", out.Payload)
|
|
}
|
|
wantAsOf := time.Date(2026, 6, 11, 19, 45, 0, 0, time.UTC)
|
|
if !run.AsOf.Equal(wantAsOf) {
|
|
t.Fatalf("AsOf = %s, want %s", run.AsOf, wantAsOf)
|
|
}
|
|
if run.IssuedAt == nil || !run.IssuedAt.Equal(wantAsOf) {
|
|
t.Fatalf("IssuedAt = %v, want %s", run.IssuedAt, wantAsOf)
|
|
}
|
|
if out.EffectiveAt == nil || !out.EffectiveAt.Equal(wantAsOf) {
|
|
t.Fatalf("EffectiveAt = %v, want %s", out.EffectiveAt, wantAsOf)
|
|
}
|
|
if run.LocationID != "stl" || run.LocationName != "St. Louis, MO" {
|
|
t.Fatalf("location metadata = %q/%q", run.LocationID, run.LocationName)
|
|
}
|
|
if run.Latitude == nil || *run.Latitude != 38.5 || run.Longitude == nil || *run.Longitude != -90.5 {
|
|
t.Fatalf("coordinates = %v,%v", run.Latitude, run.Longitude)
|
|
}
|
|
if len(run.Outlooks) != 9 {
|
|
t.Fatalf("Outlooks length = %d, want 9", len(run.Outlooks))
|
|
}
|
|
|
|
got := run.Outlooks[0]
|
|
if got.Provider != "spc" || got.Product != "convective" {
|
|
t.Fatalf("provider/product = %q/%q", got.Provider, got.Product)
|
|
}
|
|
if got.Day != 1 || got.OutlookType != spcprovider.OutlookTypeCategorical {
|
|
t.Fatalf("day/type = %d/%q", got.Day, got.OutlookType)
|
|
}
|
|
if got.Label != "SLGT" || got.LabelText != "Slight Risk" {
|
|
t.Fatalf("label fields = %q/%q", got.Label, got.LabelText)
|
|
}
|
|
if got.SeverityRank == nil || *got.SeverityRank != 3 {
|
|
t.Fatalf("SeverityRank = %v, want 3", got.SeverityRank)
|
|
}
|
|
assertTime(t, "ValidFrom", got.ValidFrom, 2026, 6, 11, 13, 0, 0)
|
|
assertTime(t, "ValidTo", got.ValidTo, 2026, 6, 12, 12, 0, 0)
|
|
assertTime(t, "IssuedAt", got.IssuedAt, 2026, 6, 11, 12, 34, 56)
|
|
assertTime(t, "ExpiresAt", got.ExpiresAt, 2026, 6, 12, 12, 0, 0)
|
|
if got.Forecaster != "SMITH" {
|
|
t.Fatalf("Forecaster = %q, want SMITH", got.Forecaster)
|
|
}
|
|
if got.SourceURL != "https://example.invalid/day1_categorical.geojson" {
|
|
t.Fatalf("SourceURL = %q", got.SourceURL)
|
|
}
|
|
wantGeometry := `{"type":"Polygon","coordinates":[[[-91.0,38.0],[-90.0,38.0],[-90.0,39.0],[-91.0,39.0],[-91.0,38.0]]]}`
|
|
if string(got.Geometry) != wantGeometry {
|
|
t.Fatalf("Geometry = %s, want %s", got.Geometry, wantGeometry)
|
|
}
|
|
if !got.ContainsLocation {
|
|
t.Fatalf("ContainsLocation = false, want true")
|
|
}
|
|
if got.Headline != "Day 1 Convective Outlook" {
|
|
t.Fatalf("Headline = %q", got.Headline)
|
|
}
|
|
if !strings.Contains(got.Summary, "central Plains") {
|
|
t.Fatalf("Summary = %q", got.Summary)
|
|
}
|
|
if !strings.Contains(got.Discussion, "...DISCUSSION...") {
|
|
t.Fatalf("Discussion missing product text: %q", got.Discussion)
|
|
}
|
|
if !strings.HasPrefix(got.Discussion, "SPC AC 111234") {
|
|
t.Fatalf("Discussion = %q, want SPC product code prefix", got.Discussion)
|
|
}
|
|
if got.ID != "spc-convective-day1-categorical-slgt-2026-06-11T12:34:56Z-2026-06-11T13:00:00Z-0" {
|
|
t.Fatalf("ID = %q", got.ID)
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerAcceptsTypedSourcePayload(t *testing.T) {
|
|
bundle := spcBundle(t, 38.5, -90.5)
|
|
in := spcRawEvent(t, bundle)
|
|
in.Payload = bundle
|
|
|
|
out, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, in)
|
|
if err != nil {
|
|
t.Fatalf("Normalize() error = %v", err)
|
|
}
|
|
run := out.Payload.(model.WeatherOutlookRun)
|
|
if len(run.Outlooks) != 9 {
|
|
t.Fatalf("Outlooks length = %d, want 9", len(run.Outlooks))
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerOrdersProductsByDayAndType(t *testing.T) {
|
|
bundle := spcBundle(t, 0, 0)
|
|
for i, j := 0, len(bundle.Products)-1; i < j; i, j = i+1, j-1 {
|
|
bundle.Products[i], bundle.Products[j] = bundle.Products[j], bundle.Products[i]
|
|
}
|
|
|
|
out, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, bundle))
|
|
if err != nil {
|
|
t.Fatalf("Normalize() error = %v", err)
|
|
}
|
|
run := out.Payload.(model.WeatherOutlookRun)
|
|
got := []string{
|
|
run.Outlooks[0].OutlookType,
|
|
run.Outlooks[1].OutlookType,
|
|
run.Outlooks[2].OutlookType,
|
|
run.Outlooks[3].OutlookType,
|
|
}
|
|
want := []string{
|
|
spcprovider.OutlookTypeCategorical,
|
|
spcprovider.OutlookTypeTornado,
|
|
spcprovider.OutlookTypeHail,
|
|
spcprovider.OutlookTypeWind,
|
|
}
|
|
for i := range want {
|
|
if got[i] != want[i] || run.Outlooks[i].Day != 1 {
|
|
t.Fatalf("outlook[%d] = day %d type %q, want day 1 type %q", i, run.Outlooks[i].Day, got[i], want[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerMapsProbabilisticOutlookTypes(t *testing.T) {
|
|
out, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, spcBundle(t, 0, 0)))
|
|
if err != nil {
|
|
t.Fatalf("Normalize() error = %v", err)
|
|
}
|
|
run := out.Payload.(model.WeatherOutlookRun)
|
|
for _, outlookType := range []string{
|
|
spcprovider.OutlookTypeTornado,
|
|
spcprovider.OutlookTypeHail,
|
|
spcprovider.OutlookTypeWind,
|
|
} {
|
|
if findOutlook(run.Outlooks, 1, outlookType) == nil {
|
|
t.Fatalf("missing day 1 outlook type %q", outlookType)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerContainsLocationFalseOutsidePolygon(t *testing.T) {
|
|
out, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, spcBundle(t, 0, 0)))
|
|
if err != nil {
|
|
t.Fatalf("Normalize() error = %v", err)
|
|
}
|
|
run := out.Payload.(model.WeatherOutlookRun)
|
|
if run.Outlooks[0].ContainsLocation {
|
|
t.Fatalf("ContainsLocation = true, want false")
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerPreservesCorrectionMarker(t *testing.T) {
|
|
out, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, spcBundle(t, 0, 0)))
|
|
if err != nil {
|
|
t.Fatalf("Normalize() error = %v", err)
|
|
}
|
|
run := out.Payload.(model.WeatherOutlookRun)
|
|
got := findOutlook(run.Outlooks, 2, spcprovider.OutlookTypeTornado)
|
|
if got == nil {
|
|
t.Fatalf("missing day 2 tornado outlook")
|
|
}
|
|
if !strings.Contains(got.Headline, "CORR 1") {
|
|
t.Fatalf("Headline = %q, want correction marker", got.Headline)
|
|
}
|
|
if !strings.Contains(got.Discussion, "CORR 1") {
|
|
t.Fatalf("Discussion = %q, want correction marker", got.Discussion)
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerMissingRSSNormalizes(t *testing.T) {
|
|
bundle := spcBundle(t, 0, 0)
|
|
bundle.RSS = nil
|
|
if _, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, bundle)); err != nil {
|
|
t.Fatalf("Normalize() error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerInvalidRequiredTimestampFailsWithContext(t *testing.T) {
|
|
bundle := spcBundle(t, 0, 0)
|
|
bundle.Products[0].Body = json.RawMessage(strings.Replace(
|
|
string(bundle.Products[0].Body),
|
|
`"ISSUE_ISO": "2026-06-11T12:34:56Z"`,
|
|
`"ISSUE_ISO": "bad"`,
|
|
1,
|
|
))
|
|
|
|
_, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, bundle))
|
|
if err == nil {
|
|
t.Fatalf("Normalize() error = nil, want error")
|
|
}
|
|
if !strings.Contains(err.Error(), "product day1_categorical feature 0.ISSUE_ISO") {
|
|
t.Fatalf("error = %q, want product and feature context", err)
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerInvalidGeometryFailsWithContext(t *testing.T) {
|
|
bundle := spcBundle(t, 0, 0)
|
|
bundle.Products[0].Body = json.RawMessage(strings.Replace(
|
|
string(bundle.Products[0].Body),
|
|
`"geometry": {`,
|
|
`"geometry": {"type":"LineString","coordinates":[[-91,38],[-90,39]]}, "oldGeometry": {`,
|
|
1,
|
|
))
|
|
|
|
_, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, bundle))
|
|
if err == nil {
|
|
t.Fatalf("Normalize() error = nil, want error")
|
|
}
|
|
if !strings.Contains(err.Error(), "product day1_categorical feature 0.geometry") {
|
|
t.Fatalf("error = %q, want product and feature context", err)
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerRejectsMissingLabel(t *testing.T) {
|
|
bundle := spcBundle(t, 0, 0)
|
|
bundle.Products[0].Body = json.RawMessage(strings.Replace(
|
|
string(bundle.Products[0].Body),
|
|
`"LABEL": "SLGT"`,
|
|
`"LABEL": ""`,
|
|
1,
|
|
))
|
|
|
|
_, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, bundle))
|
|
if err == nil {
|
|
t.Fatalf("Normalize() error = nil, want error")
|
|
}
|
|
if !strings.Contains(err.Error(), "product day1_categorical feature 0.LABEL") {
|
|
t.Fatalf("error = %q, want label context", err)
|
|
}
|
|
}
|
|
|
|
func TestConvectiveOutlookNormalizerOutputJSONShape(t *testing.T) {
|
|
out, err := (ConvectiveOutlookNormalizer{}).Normalize(nil, spcRawEvent(t, spcBundle(t, 38.5, -90.5)))
|
|
if err != nil {
|
|
t.Fatalf("Normalize() error = %v", err)
|
|
}
|
|
raw, err := json.Marshal(out.Payload)
|
|
if err != nil {
|
|
t.Fatalf("Marshal(payload) error = %v", err)
|
|
}
|
|
got := string(raw)
|
|
for _, want := range []string{`"asOf"`, `"outlooks"`, `"containsLocation"`, `"geometry"`} {
|
|
if !strings.Contains(got, want) {
|
|
t.Fatalf("payload JSON missing %s: %s", want, got)
|
|
}
|
|
}
|
|
for _, unwanted := range []string{`"products"`, `"discussions"`, `"fetchedAt"`, `"body"`} {
|
|
if strings.Contains(got, unwanted) {
|
|
t.Fatalf("payload JSON exposed raw key %s: %s", unwanted, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func spcRawEvent(t *testing.T, bundle spcprovider.RawConvectiveOutlookBundle) event.Event {
|
|
t.Helper()
|
|
raw, err := json.Marshal(bundle)
|
|
if err != nil {
|
|
t.Fatalf("Marshal(bundle) error = %v", err)
|
|
}
|
|
effectiveAt := time.Date(2026, 6, 11, 19, 45, 0, 0, time.UTC)
|
|
return event.Event{
|
|
ID: "evt-spc-outlook-1",
|
|
Kind: event.Kind(standards.KindOutlook),
|
|
Source: "spc-test",
|
|
EmittedAt: time.Date(2026, 6, 11, 20, 5, 0, 0, time.UTC),
|
|
EffectiveAt: &effectiveAt,
|
|
Schema: standards.SchemaRawSPCConvectiveOutlookV1,
|
|
Payload: json.RawMessage(raw),
|
|
}
|
|
}
|
|
|
|
func spcBundle(t *testing.T, latitude, longitude float64) spcprovider.RawConvectiveOutlookBundle {
|
|
t.Helper()
|
|
fetchedAt := time.Date(2026, 6, 11, 20, 0, 0, 0, time.UTC)
|
|
products := make([]spcprovider.RawOutlookProduct, 0, len(spcprovider.GeoJSONProducts()))
|
|
for _, product := range spcprovider.GeoJSONProducts() {
|
|
products = append(products, spcprovider.RawOutlookProduct{
|
|
Key: product.Key,
|
|
Day: product.Day,
|
|
OutlookType: product.OutlookType,
|
|
URL: "https://example.invalid/" + product.Key + ".geojson",
|
|
FetchedAt: fetchedAt,
|
|
Body: json.RawMessage(geoJSONFixtureForProduct(t, product.Key)),
|
|
})
|
|
}
|
|
return spcprovider.RawConvectiveOutlookBundle{
|
|
LocationID: "stl",
|
|
LocationName: "St. Louis, MO",
|
|
Latitude: latitude,
|
|
Longitude: longitude,
|
|
FetchedAt: fetchedAt,
|
|
Products: products,
|
|
Discussions: []spcprovider.RawDiscussionPage{
|
|
{Key: "day1", Day: 1, URL: "https://example.invalid/day1.html", FetchedAt: fetchedAt, Body: string(readSPCTestFixture(t, "day1_prt.html"))},
|
|
{Key: "day2", Day: 2, URL: "https://example.invalid/day2.html", FetchedAt: fetchedAt, Body: string(readSPCTestFixture(t, "day2_prt_corr.html"))},
|
|
{Key: "day3", Day: 3, URL: "https://example.invalid/day3.html", FetchedAt: fetchedAt, Body: string(readSPCTestFixture(t, "day3_prt.html"))},
|
|
},
|
|
}
|
|
}
|
|
|
|
func geoJSONFixtureForProduct(t *testing.T, key string) []byte {
|
|
t.Helper()
|
|
switch {
|
|
case strings.HasPrefix(key, "day1_"):
|
|
return readSPCTestFixture(t, "day1_cat.geojson")
|
|
case strings.HasPrefix(key, "day2_"):
|
|
return readSPCTestFixture(t, "day2_torn.geojson")
|
|
case strings.HasPrefix(key, "day3_"):
|
|
return readSPCTestFixture(t, "day3_cat.geojson")
|
|
default:
|
|
t.Fatalf("unknown product key %q", key)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func readSPCTestFixture(t *testing.T, name string) []byte {
|
|
t.Helper()
|
|
path := filepath.Join("..", "..", "providers", "spc", "testdata", name)
|
|
raw, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("read fixture %s: %v", path, err)
|
|
}
|
|
return raw
|
|
}
|
|
|
|
func findOutlook(outlooks []model.WeatherOutlook, day int, outlookType string) *model.WeatherOutlook {
|
|
for i := range outlooks {
|
|
if outlooks[i].Day == day && outlooks[i].OutlookType == outlookType {
|
|
return &outlooks[i]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func assertTime(t *testing.T, name string, got time.Time, year int, month time.Month, day int, hour int, minute int, second int) {
|
|
t.Helper()
|
|
want := time.Date(year, month, day, hour, minute, second, 0, time.UTC)
|
|
if !got.Equal(want) {
|
|
t.Fatalf("%s = %s, want %s", name, got, want)
|
|
}
|
|
}
|