Centralize report name resolution

internal/report/names.go

@@ -0,0 +1,86 @@
+package report
+
+import (
+	"fmt"
+	"strings"
+)
+
+const (
+	CommandNameDaily    = "daily"
+	CommandNameTomorrow = "tomorrow"
+	CommandNameHourly   = "hourly"
+	CommandNameThreeDay = "three-day"
+	CommandNameWeekend  = "weekend"
+	CommandNameStorm    = "storm"
+
+	BatchNameMorning = "morning"
+	BatchNameEvening = "evening"
+)
+
+func IDForCommandName(name string) (ID, error) {
+	switch name {
+	case CommandNameDaily:
+		return DailyToday, nil
+	case CommandNameTomorrow:
+		return Tomorrow, nil
+	case CommandNameHourly:
+		return Hourly, nil
+	case CommandNameThreeDay:
+		return ThreeDay, nil
+	case CommandNameWeekend:
+		return Weekend, nil
+	case CommandNameStorm:
+		return Storm, nil
+	default:
+		return "", fmt.Errorf("unknown report command %q", name)
+	}
+}
+
+func CommandNames() []string {
+	return []string{
+		CommandNameDaily,
+		CommandNameTomorrow,
+		CommandNameHourly,
+		CommandNameThreeDay,
+		CommandNameWeekend,
+		CommandNameStorm,
+	}
+}
+
+func IDForConfigKey(key string) (ID, error) {
+	normalized := strings.ReplaceAll(strings.TrimSpace(strings.ToLower(key)), "-", "_")
+	switch normalized {
+	case "daily", "daily_today":
+		return DailyToday, nil
+	case "tomorrow":
+		return Tomorrow, nil
+	case "hourly":
+		return Hourly, nil
+	case "three_day", "three_day_outlook":
+		return ThreeDay, nil
+	case "weekend", "weekend_outlook":
+		return Weekend, nil
+	case "storm", "storm_report":
+		return Storm, nil
+	default:
+		return "", fmt.Errorf("report config key %q is not a known report", key)
+	}
+}
+
+func BatchForCommandName(name string) (Batch, error) {
+	switch name {
+	case BatchNameMorning:
+		return Morning, nil
+	case BatchNameEvening:
+		return Evening, nil
+	default:
+		return "", fmt.Errorf("unknown batch command %q", name)
+	}
+}
+
+func BatchCommandNames() []string {
+	return []string{
+		BatchNameMorning,
+		BatchNameEvening,
+	}
+}

internal/report/period_test.go

@@ -240,6 +240,113 @@ func TestBatchesDoNotIncludeHourly(t *testing.T) {
 	}
 }
 
+func TestIDForCommandName(t *testing.T) {
+	tests := []struct {
+		name string
+		want ID
+	}{
+		{name: "daily", want: DailyToday},
+		{name: "tomorrow", want: Tomorrow},
+		{name: "hourly", want: Hourly},
+		{name: "three-day", want: ThreeDay},
+		{name: "weekend", want: Weekend},
+		{name: "storm", want: Storm},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := IDForCommandName(tt.name)
+			if err != nil {
+				t.Fatalf("IDForCommandName() error = %v", err)
+			}
+			if got != tt.want {
+				t.Fatalf("IDForCommandName() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+	if names := strings.Join(CommandNames(), ","); names != "daily,tomorrow,hourly,three-day,weekend,storm" {
+		t.Fatalf("CommandNames() = %s, want stable command names", names)
+	}
+	if _, err := IDForCommandName("near-term"); err == nil || !strings.Contains(err.Error(), `unknown report command "near-term"`) {
+		t.Fatalf("IDForCommandName(near-term) error = %v, want unknown command", err)
+	}
+}
+
+func TestIDForConfigKey(t *testing.T) {
+	tests := []struct {
+		key  string
+		want ID
+	}{
+		{key: "daily", want: DailyToday},
+		{key: "daily_today", want: DailyToday},
+		{key: "tomorrow", want: Tomorrow},
+		{key: "hourly", want: Hourly},
+		{key: "three_day", want: ThreeDay},
+		{key: "three-day", want: ThreeDay},
+		{key: "three_day_outlook", want: ThreeDay},
+		{key: "three-day-outlook", want: ThreeDay},
+		{key: "weekend", want: Weekend},
+		{key: "weekend_outlook", want: Weekend},
+		{key: "storm", want: Storm},
+		{key: "storm_report", want: Storm},
+	}
+	for _, tt := range tests {
+		t.Run(tt.key, func(t *testing.T) {
+			got, err := IDForConfigKey(tt.key)
+			if err != nil {
+				t.Fatalf("IDForConfigKey() error = %v", err)
+			}
+			if got != tt.want {
+				t.Fatalf("IDForConfigKey() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+	if _, err := IDForConfigKey("daily_tomorrow"); err == nil || !strings.Contains(err.Error(), `report config key "daily_tomorrow" is not a known report`) {
+		t.Fatalf("IDForConfigKey(daily_tomorrow) error = %v, want unknown key", err)
+	}
+}
+
+func TestBatchForCommandName(t *testing.T) {
+	tests := []struct {
+		name string
+		want Batch
+	}{
+		{name: "morning", want: Morning},
+		{name: "evening", want: Evening},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := BatchForCommandName(tt.name)
+			if err != nil {
+				t.Fatalf("BatchForCommandName() error = %v", err)
+			}
+			if got != tt.want {
+				t.Fatalf("BatchForCommandName() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+	if names := strings.Join(BatchCommandNames(), ","); names != "morning,evening" {
+		t.Fatalf("BatchCommandNames() = %s, want stable batch command names", names)
+	}
+	if _, err := BatchForCommandName("hourly"); err == nil || !strings.Contains(err.Error(), `unknown batch command "hourly"`) {
+		t.Fatalf("BatchForCommandName(hourly) error = %v, want unknown batch", err)
+	}
+}
+
+func TestMorningBatchReportOrder(t *testing.T) {
+	location := mustLoadLocation(t)
+	resolved, err := DefaultRegistry().BatchReports(Morning, ResolveRequest{
+		Now:      mustParse("2026-05-29T06:00:00-05:00"),
+		Location: location,
+	})
+	if err != nil {
+		t.Fatalf("BatchReports() error = %v", err)
+	}
+	ids := resolvedIDs(resolved)
+	if strings.Join(ids, ",") != "daily_today,three_day,weekend" {
+		t.Fatalf("ids = %v, want morning report order", ids)
+	}
+}
+
 func TestRegistryLookupErrorIsActionable(t *testing.T) {
 	_, err := DefaultRegistry().Lookup(ID("unknown"))
 	if err == nil {