236 lines
12 KiB
Go
236 lines
12 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/comparison"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/promptexec"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
|
|
)
|
|
|
|
func TestCompareDetailedPublishesOneCoherentBundle(t *testing.T) {
|
|
cfg := comparisonConfig()
|
|
bundle := generationBundle(t)
|
|
workingDir := t.TempDir()
|
|
executor := &generationExecutor{}
|
|
inspectedBeforeCollection := false
|
|
result, err := CompareDetailed(context.Background(), ComparisonRequest{
|
|
Config: cfg, Report: ReportDaily, ProfileIDs: []string{"weather-light", "weather-deep"},
|
|
WorkingDir: workingDir, Date: generationTime("2026-05-29T12:00:00-05:00"),
|
|
Clock: timeutil.FixedClock{Time: generationTime("2026-05-29T08:30:00-05:00")},
|
|
Collector: &generationCollector{bundle: &bundle, beforeRun: func() {
|
|
inspectedBeforeCollection = executor.promptInspections == 1 && executor.profileInspections == 2
|
|
}}, Executor: executor,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CompareDetailed() error = %v", err)
|
|
}
|
|
if result == nil || result.Total != 2 || result.Succeeded != 2 || result.Failed != 0 || executor.promptInspections != 1 || executor.profileInspections != 2 || executor.executeCalls != 2 || !inspectedBeforeCollection || result.ManifestPath == "" || result.DataPackagePath == "" {
|
|
t.Fatalf("result/executor = %#v/%#v", result, executor)
|
|
}
|
|
if result.OutputDirectory != filepath.Dir(result.ManifestPath) || !filepath.IsAbs(result.ManifestPath) || !filepath.IsAbs(result.DataPackagePath) {
|
|
t.Fatalf("published paths = %#v", result)
|
|
}
|
|
for index, profile := range result.Results {
|
|
if profile.Position != index+1 || profile.Status != comparison.StatusSucceeded || !filepath.IsAbs(profile.ReportPath) || profile.Error != nil {
|
|
t.Fatalf("profile result = %#v", profile)
|
|
}
|
|
}
|
|
data, readErr := os.ReadFile(result.ManifestPath)
|
|
if readErr != nil {
|
|
t.Fatal(readErr)
|
|
}
|
|
var manifest comparison.Manifest
|
|
if err := json.Unmarshal(data, &manifest); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if manifest.ComparisonID != result.ComparisonID || manifest.Total != result.Total || manifest.Succeeded != result.Succeeded || manifest.DataPackage.SHA256 == "" || len(manifest.Results) != 2 {
|
|
t.Fatalf("manifest = %#v", manifest)
|
|
}
|
|
if manifest.Results[0].ReportPath != filepath.Base(result.Results[0].ReportPath) || manifest.Results[1].ReportPath != filepath.Base(result.Results[1].ReportPath) {
|
|
t.Fatalf("manifest report paths = %#v", manifest.Results)
|
|
}
|
|
}
|
|
|
|
func TestCompareDetailedPublishesPartialBundleAndReturnsAggregateError(t *testing.T) {
|
|
cfg := comparisonConfig()
|
|
bundle := generationBundle(t)
|
|
executor := &generationExecutor{executeErrors: map[string]error{"weather-deep": errors.New("provider detail must not escape")}}
|
|
result, err := CompareDetailed(context.Background(), ComparisonRequest{
|
|
Config: cfg, Report: ReportDaily, ProfileIDs: []string{"weather-light", "weather-deep", "weather-fallback"},
|
|
WorkingDir: t.TempDir(), Date: generationTime("2026-05-29T12:00:00-05:00"),
|
|
Clock: timeutil.FixedClock{Time: generationTime("2026-05-29T08:30:00-05:00")},
|
|
Collector: &generationCollector{bundle: &bundle}, Executor: executor,
|
|
})
|
|
if err == nil || err.Error() != "comparison completed with 1 failed profiles" || result == nil || result.Total != 3 || result.Succeeded != 2 || result.Failed != 1 {
|
|
t.Fatalf("CompareDetailed() result/error = %#v/%v", result, err)
|
|
}
|
|
failure := result.Results[1]
|
|
if failure.Status != comparison.StatusFailed || failure.ReportPath != "" || failure.Error == nil || strings.Contains(failure.Error.Message, "provider detail") {
|
|
t.Fatalf("failure = %#v", failure)
|
|
}
|
|
if _, statErr := os.Stat(result.ManifestPath); statErr != nil {
|
|
t.Fatalf("partial manifest: %v", statErr)
|
|
}
|
|
if _, statErr := os.Stat(filepath.Join(result.OutputDirectory, filepath.Base(result.Results[0].ReportPath))); statErr != nil {
|
|
t.Fatalf("successful partial report: %v", statErr)
|
|
}
|
|
}
|
|
|
|
func TestCompareDetailedRetainsCommittedPathsWhenBackupCleanupFails(t *testing.T) {
|
|
bundle := generationBundle(t)
|
|
backupPath := filepath.Join(t.TempDir(), ".comparison-daily.backup-retained")
|
|
cleanupCause := errors.New("backup cleanup failed")
|
|
originalPublish := publishComparison
|
|
publishComparison = func(context.Context, comparison.DestinationPlan, comparison.LogicalBundle) (comparison.PublicationResult, error) {
|
|
return comparison.PublicationResult{Committed: true, RetainedBackupPath: backupPath}, &comparison.PublicationCleanupError{RetainedBackupPath: backupPath, Err: cleanupCause}
|
|
}
|
|
t.Cleanup(func() { publishComparison = originalPublish })
|
|
|
|
result, err := CompareDetailed(context.Background(), ComparisonRequest{
|
|
Config: comparisonConfig(), Report: ReportDaily, ProfileIDs: []string{"weather-light", "weather-deep"},
|
|
WorkingDir: t.TempDir(), Date: generationTime("2026-05-29T12:00:00-05:00"),
|
|
Clock: timeutil.FixedClock{Time: generationTime("2026-05-29T08:30:00-05:00")},
|
|
Collector: &generationCollector{bundle: &bundle}, Executor: &generationExecutor{},
|
|
})
|
|
var cleanupErr *comparison.PublicationCleanupError
|
|
if result == nil || !errors.As(err, &cleanupErr) || !errors.Is(err, cleanupCause) || cleanupErr.RetainedBackupPath != backupPath || !filepath.IsAbs(result.ManifestPath) || !filepath.IsAbs(result.DataPackagePath) {
|
|
t.Fatalf("CompareDetailed() result/error = %#v/%v", result, err)
|
|
}
|
|
for _, profile := range result.Results {
|
|
if profile.Status == comparison.StatusSucceeded && !filepath.IsAbs(profile.ReportPath) {
|
|
t.Fatalf("published profile result = %#v", profile)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompareDetailedPreflightsBeforePromptOrCollection(t *testing.T) {
|
|
invalidDestination := filepath.Join(t.TempDir(), "not-a-directory")
|
|
if err := os.WriteFile(invalidDestination, []byte("x"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
bundle := generationBundle(t)
|
|
collector := &generationCollector{bundle: &bundle}
|
|
executor := &generationExecutor{}
|
|
result, err := CompareDetailed(context.Background(), ComparisonRequest{
|
|
Config: comparisonConfig(), Report: ReportDaily, ProfileIDs: []string{"weather-light", "weather-deep"},
|
|
WorkingDir: t.TempDir(), OutputDir: invalidDestination, Date: generationTime("2026-05-29T12:00:00-05:00"),
|
|
Clock: timeutil.FixedClock{Time: generationTime("2026-05-29T08:30:00-05:00")}, Collector: collector, Executor: executor,
|
|
})
|
|
if err == nil || result == nil || collector.called || executor.promptInspections != 0 || executor.executeCalls != 0 || result.ManifestPath != "" {
|
|
t.Fatalf("result/error/collector/executor = %#v/%v/%#v/%#v", result, err, collector, executor)
|
|
}
|
|
}
|
|
|
|
func TestCompareDetailedLeavesDestinationWhenCollectionOrPreparationFails(t *testing.T) {
|
|
collectionErr := errors.New("weather collection failed")
|
|
for _, test := range []struct {
|
|
name string
|
|
collector *generationCollector
|
|
}{
|
|
{name: "collection", collector: &generationCollector{err: collectionErr}},
|
|
{name: "preparation", collector: &generationCollector{bundle: &weatherdata.Bundle{}}},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
workingDir := t.TempDir()
|
|
executor := &generationExecutor{}
|
|
result, err := CompareDetailed(context.Background(), ComparisonRequest{
|
|
Config: comparisonConfig(), Report: ReportDaily, ProfileIDs: []string{"weather-light", "weather-deep"},
|
|
WorkingDir: workingDir, Date: generationTime("2026-05-29T12:00:00-05:00"),
|
|
Clock: timeutil.FixedClock{Time: generationTime("2026-05-29T08:30:00-05:00")}, Collector: test.collector, Executor: executor,
|
|
})
|
|
if err == nil || result == nil || executor.executeCalls != 0 || result.ManifestPath != "" || result.DataPackagePath != "" {
|
|
t.Fatalf("CompareDetailed() result/error/executor = %#v/%v/%#v", result, err, executor)
|
|
}
|
|
if _, statErr := os.Stat(filepath.Join(workingDir, "comparison-daily-2026-05-29")); !os.IsNotExist(statErr) {
|
|
t.Fatalf("comparison destination stat error = %v", statErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCompareDetailedPublishesManifestWhenEveryProfileFails(t *testing.T) {
|
|
bundle := generationBundle(t)
|
|
executor := &generationExecutor{executeErrors: map[string]error{
|
|
"weather-light": errors.New("first provider failure"), "weather-deep": errors.New("second provider failure"),
|
|
}}
|
|
result, err := CompareDetailed(context.Background(), ComparisonRequest{
|
|
Config: comparisonConfig(), Report: ReportDaily, ProfileIDs: []string{"weather-light", "weather-deep"},
|
|
WorkingDir: t.TempDir(), Date: generationTime("2026-05-29T12:00:00-05:00"),
|
|
Clock: timeutil.FixedClock{Time: generationTime("2026-05-29T08:30:00-05:00")},
|
|
Collector: &generationCollector{bundle: &bundle}, Executor: executor,
|
|
})
|
|
if err == nil || err.Error() != "comparison completed with 2 failed profiles" || result == nil || result.Succeeded != 0 || result.Failed != 2 || result.ManifestPath == "" {
|
|
t.Fatalf("CompareDetailed() result/error = %#v/%v", result, err)
|
|
}
|
|
for _, profile := range result.Results {
|
|
if profile.ReportPath != "" || profile.Error == nil {
|
|
t.Fatalf("failed profile = %#v", profile)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompareDetailedCancellationPreservesPublishedBundle(t *testing.T) {
|
|
workingDir := t.TempDir()
|
|
bundle := generationBundle(t)
|
|
request := ComparisonRequest{
|
|
Config: comparisonConfig(), Report: ReportDaily, ProfileIDs: []string{"weather-light", "weather-deep"},
|
|
WorkingDir: workingDir, Date: generationTime("2026-05-29T12:00:00-05:00"),
|
|
Clock: timeutil.FixedClock{Time: generationTime("2026-05-29T08:30:00-05:00")}, Collector: &generationCollector{bundle: &bundle}, Executor: &generationExecutor{},
|
|
}
|
|
previous, err := CompareDetailed(context.Background(), request)
|
|
if err != nil {
|
|
t.Fatalf("initial CompareDetailed() error = %v", err)
|
|
}
|
|
before, err := os.ReadFile(previous.ManifestPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
request.Replace = true
|
|
request.Executor = &generationExecutor{cancelBeforeReturn: cancel}
|
|
result, err := CompareDetailed(ctx, request)
|
|
if !errors.Is(err, context.Canceled) || result == nil || result.ManifestPath != "" || result.DataPackagePath != "" {
|
|
t.Fatalf("canceled CompareDetailed() result/error = %#v/%v", result, err)
|
|
}
|
|
after, readErr := os.ReadFile(previous.ManifestPath)
|
|
if readErr != nil || string(after) != string(before) {
|
|
t.Fatalf("published manifest changed = %q, error = %v", after, readErr)
|
|
}
|
|
}
|
|
|
|
func TestCompareDetailedLeavesExistingBundleWhenPublicationPreflightChanges(t *testing.T) {
|
|
workingDir := t.TempDir()
|
|
target := filepath.Join(workingDir, "comparison-output")
|
|
bundle := generationBundle(t)
|
|
executor := &generationExecutor{beforeExecute: func(promptexec.ExecuteRequest) {
|
|
_ = os.WriteFile(target, []byte("changed"), 0o600)
|
|
}}
|
|
result, err := CompareDetailed(context.Background(), ComparisonRequest{
|
|
Config: comparisonConfig(), Report: ReportDaily, ProfileIDs: []string{"weather-light", "weather-deep"},
|
|
WorkingDir: workingDir, OutputDir: target, Date: generationTime("2026-05-29T12:00:00-05:00"),
|
|
Clock: timeutil.FixedClock{Time: generationTime("2026-05-29T08:30:00-05:00")}, Collector: &generationCollector{bundle: &bundle}, Executor: executor,
|
|
})
|
|
if err == nil || result == nil || result.ManifestPath != "" || result.DataPackagePath != "" || result.Results[0].ReportPath != "" {
|
|
t.Fatalf("CompareDetailed() result/error = %#v/%v", result, err)
|
|
}
|
|
data, readErr := os.ReadFile(target)
|
|
if readErr != nil || string(data) != "changed" {
|
|
t.Fatalf("destination = %q, error = %v", data, readErr)
|
|
}
|
|
}
|
|
|
|
func comparisonConfig() config.Config {
|
|
cfg := config.Defaults()
|
|
cfg.WeatherAPI.Timezone, cfg.Location.ID = "America/Chicago", "home"
|
|
return cfg
|
|
}
|