weatherreporter/internal/briefing/modules_test.go

package briefing

import (
	"strings"
	"testing"

	"gitea.maximumdirect.net/eric/weatherreporter/internal/facts"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
	"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
)

func TestDefaultModuleRegistryValidatesReportDefaults(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	for _, definition := range report.DefaultRegistry().All() {
		if err := registry.ValidateComposition(definition.ID, definition.Modules); err != nil {
			t.Fatalf("ValidateComposition(%s) error = %v", definition.ID, err)
		}
		for _, item := range definition.Modules {
			moduleDefinition, err := registry.Lookup(item.ID)
			if err != nil {
				t.Fatalf("Lookup(%s) error = %v", item.ID, err)
			}
			if moduleDefinition.Builder == nil {
				t.Fatalf("report %s module %s has no builder", definition.ID, item.ID)
			}
		}
	}
}

func TestDefaultReportModulesBuildSnapshots(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	for _, definition := range report.DefaultRegistry().All() {
		t.Run(string(definition.ID), func(t *testing.T) {
			ctx := derivedModuleContext(definition.ID)
			var outputs []module.Output
			for _, item := range definition.Modules {
				output, err := registry.BuildModule(ctx, item)
				if err != nil {
					t.Fatalf("BuildModule(%s) error = %v", item.ID, err)
				}
				if output != nil {
					outputs = append(outputs, *output)
				}
			}
			snapshot, err := module.NewSnapshot(outputs)
			if err != nil {
				t.Fatalf("NewSnapshot() error = %v", err)
			}
			if len(snapshot.Outputs) == 0 {
				t.Fatal("snapshot outputs = 0, want default report modules")
			}
		})
	}
}

func TestHourlyDefaultModuleOptions(t *testing.T) {
	definition := report.DefaultRegistry().MustLookup(report.Hourly)
	var found bool
	for _, item := range definition.Modules {
		if item.ID != module.AreaForecastDiscussion {
			continue
		}
		found = true
		options, ok := item.Options.(module.AreaForecastDiscussionOptions)
		if !ok {
			t.Fatalf("AFD options type = %T, want AreaForecastDiscussionOptions", item.Options)
		}
		if strings.Join(options.Sections, ",") != "key_messages,short_term" {
			t.Fatalf("AFD sections = %#v, want key messages and short term", options.Sections)
		}
	}
	if !found {
		t.Fatal("hourly default modules missing area_forecast_discussion")
	}
}

func TestModuleRegistryRejectsUnknownModule(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{{ID: module.ID("unknown")}})
	if err == nil || !strings.Contains(err.Error(), `unknown module "unknown"`) {
		t.Fatalf("error = %v, want unknown module", err)
	}
}

func TestModuleRegistryRejectsDuplicateModuleIDs(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{
		{ID: module.Metadata},
		{ID: module.Metadata},
	})
	if err == nil || !strings.Contains(err.Error(), `duplicate module "metadata"`) {
		t.Fatalf("error = %v, want duplicate module", err)
	}
}

func TestModuleRegistryRejectsDuplicateStanzaNames(t *testing.T) {
	_, err := NewModuleRegistry([]ModuleDefinition{
		{ID: module.Metadata, StanzaName: "metadata", DefaultOptions: module.MetadataOptions{}, Builder: noopModuleBuilder},
		{ID: module.CurrentConditions, StanzaName: "metadata", DefaultOptions: module.CurrentConditionsOptions{}, Builder: noopModuleBuilder},
	})
	if err == nil || !strings.Contains(err.Error(), `duplicate stanza name "metadata"`) {
		t.Fatalf("error = %v, want duplicate stanza name", err)
	}
}

func TestModuleRegistryRejectsIncompatibleReports(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{{ID: module.TomorrowPlanning}})
	if err == nil || !strings.Contains(err.Error(), `module "tomorrow_planning" is not compatible with report "daily_today"`) {
		t.Fatalf("error = %v, want incompatible report", err)
	}
}

func TestModuleRegistryValidatesTodayPlanningSupport(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	if err := registry.ValidateComposition(report.Today, []module.ConfigItem{{ID: module.TodayPlanning}}); err != nil {
		t.Fatalf("ValidateComposition(today) error = %v", err)
	}
	for _, id := range []report.ID{report.Tomorrow, report.DailyToday} {
		t.Run(string(id), func(t *testing.T) {
			err := registry.ValidateComposition(id, []module.ConfigItem{{ID: module.TodayPlanning}})
			if err == nil || !strings.Contains(err.Error(), `module "today_planning" is not compatible with report`) {
				t.Fatalf("ValidateComposition(%s) error = %v, want incompatible report", id, err)
			}
		})
	}
}

func TestModuleRegistryValidatesDailyPlanningSupport(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	if err := registry.ValidateComposition(report.ID("daily"), []module.ConfigItem{{ID: module.DailyPlanning}}); err != nil {
		t.Fatalf("ValidateComposition(daily) error = %v", err)
	}
	for _, id := range []report.ID{report.DailyToday, report.Today, report.Tomorrow, report.Hourly, report.ThreeDay, report.Weekend, report.Storm} {
		t.Run(string(id), func(t *testing.T) {
			err := registry.ValidateComposition(id, []module.ConfigItem{{ID: module.DailyPlanning}})
			if err == nil || !strings.Contains(err.Error(), `module "daily_planning" is not compatible with report`) {
				t.Fatalf("ValidateComposition(%s) error = %v, want incompatible report", id, err)
			}
		})
	}
}

func TestModuleRegistrySupportsTodayEligibleModules(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	err := registry.ValidateComposition(report.Today, []module.ConfigItem{
		{ID: module.Metadata},
		{ID: module.CurrentConditions},
		{ID: module.NarrativeForecast},
		{ID: module.HourlyForecast},
		{ID: module.DerivedDailySummary},
		{ID: module.DerivedDaypartSummaries},
		{ID: module.PrecipTiming},
		{ID: module.AlertDigest},
		{ID: module.SPCConvectiveOutlooks},
		{ID: module.AreaForecastDiscussion},
		{ID: module.SPCConvectiveDiscussion},
		{ID: module.WeatherStory},
		{ID: module.OutdoorWindows},
	})
	if err != nil {
		t.Fatalf("ValidateComposition(today eligible modules) error = %v", err)
	}
}

func TestModuleRegistryRejectsHourlyIncompatibleModules(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	for _, id := range []module.ID{
		module.NarrativeForecast,
		module.DerivedDailySummary,
		module.DerivedDaypartSummaries,
		module.OutdoorWindows,
		module.TodayPlanning,
		module.TomorrowPlanning,
		module.DailyPlanning,
	} {
		t.Run(string(id), func(t *testing.T) {
			err := registry.ValidateComposition(report.Hourly, []module.ConfigItem{{ID: id}})
			if err == nil || !strings.Contains(err.Error(), `not compatible with report "hourly"`) {
				t.Fatalf("ValidateComposition() error = %v, want incompatible hourly module", err)
			}
		})
	}
}

func TestModuleRegistryRejectsDefinitionsWithoutBuilders(t *testing.T) {
	_, err := NewModuleRegistry([]ModuleDefinition{
		{ID: module.Metadata, StanzaName: "metadata", DefaultOptions: module.MetadataOptions{}},
	})
	if err == nil || !strings.Contains(err.Error(), `module "metadata" has no builder`) {
		t.Fatalf("error = %v, want missing builder", err)
	}
}

func TestModuleRegistryRejectsUnsupportedMissingDataWarn(t *testing.T) {
	_, err := NewModuleRegistry([]ModuleDefinition{
		{ID: module.Metadata, StanzaName: "metadata", DefaultOptions: module.MetadataOptions{}, MissingData: module.MissingDataWarn, Builder: noopModuleBuilder},
	})
	if err == nil || !strings.Contains(err.Error(), `unsupported missing data behavior`) {
		t.Fatalf("error = %v, want unsupported missing-data behavior", err)
	}
}

func TestModuleRegistryRejectsInvalidOptionShapes(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{
		{ID: module.Metadata, Options: module.CurrentConditionsOptions{}},
	})
	if err == nil || !strings.Contains(err.Error(), `module "metadata" options have type module.CurrentConditionsOptions, want module.MetadataOptions`) {
		t.Fatalf("error = %v, want invalid option shape", err)
	}
}

func TestModuleRegistryAcceptsTypedOptions(t *testing.T) {
	registry := MustDefaultModuleRegistry()
	err := registry.ValidateComposition(report.DailyToday, []module.ConfigItem{
		{ID: module.Metadata, Options: module.MetadataOptions{}},
		{ID: module.CurrentConditions, Options: &module.CurrentConditionsOptions{}},
	})
	if err != nil {
		t.Fatalf("ValidateComposition() error = %v", err)
	}
}

func TestSPCConvectiveOutlookCollectedRequirementAvailability(t *testing.T) {
	ctx := ModuleContext{}
	if collectedFactAvailable(module.CollectedSPCConvectiveOutlooks, ctx) {
		t.Fatal("collectedFactAvailable() = true, want false without source")
	}

	ctx.Collected = facts.CollectedFacts{SPCConvectiveOutlooks: &weatherdata.ConvectiveOutlookRun{}}
	if !collectedFactAvailable(module.CollectedSPCConvectiveOutlooks, ctx) {
		t.Fatal("collectedFactAvailable() = false, want true with checked source")
	}
}

func TestSPCConvectiveOutlookDerivedRequirementAvailability(t *testing.T) {
	ctx := ModuleContext{}
	if derivedFactAvailable(module.RequiresDerivedSPCConvectiveOutlooks, ctx) {
		t.Fatal("derivedFactAvailable() = true, want false without derived outlooks")
	}

	ctx.Derived = facts.DerivedFacts{SPCConvectiveOutlooks: []weatherdata.ConvectiveOutlook{}}
	if !derivedFactAvailable(module.RequiresDerivedSPCConvectiveOutlooks, ctx) {
		t.Fatal("derivedFactAvailable() = false, want true for checked empty derived outlooks")
	}
}

func noopModuleBuilder(ModuleContext, any) (*module.Output, error) {
	return &module.Output{ID: module.Metadata, StanzaName: "metadata", Value: struct{}{}}, nil
}