417 lines
19 KiB
Go
417 lines
19 KiB
Go
package state
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/briefing"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/config"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/module"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/promptexec"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/promptinput"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/report"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/timeutil"
|
|
"gitea.maximumdirect.net/eric/weatherreporter/internal/weatherdata"
|
|
)
|
|
|
|
func TestFilesystemPathsUseExactPromptArtifactLayout(t *testing.T) {
|
|
store := newFilesystemTestStore(t)
|
|
tests := []struct {
|
|
id report.ID
|
|
now string
|
|
date string
|
|
group string
|
|
validDate string
|
|
runID string
|
|
}{
|
|
{report.Daily, "2026-05-29T05:00:00-05:00", "2026-05-29T12:00:00-05:00", "daily", "2026-05-29", "20260529T100000.000000000Z_daily_2026-05-29"},
|
|
{report.Today, "2026-05-29T05:00:00-05:00", "", "today", "2026-05-29", "20260529T100000.000000000Z_today"},
|
|
{report.Tomorrow, "2026-05-29T18:00:00-05:00", "", "tomorrow", "2026-05-30", "20260529T230000.000000000Z_tomorrow"},
|
|
{report.Hourly, "2026-05-29T05:00:00-05:00", "", "hourly", "2026-05-29", "20260529T100000.000000000Z_hourly"},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(string(test.id), func(t *testing.T) {
|
|
resolved := resolveStateReport(t, test.id, test.now, test.date)
|
|
paths, err := store.Paths(resolved)
|
|
if err != nil {
|
|
t.Fatalf("Paths() error = %v", err)
|
|
}
|
|
want := ArtifactPaths{
|
|
ModuleSnapshot: filepath.Join(store.root, "snapshots", test.group, test.validDate, "modules."+test.runID+".json"),
|
|
Metadata: filepath.Join(store.root, "snapshots", test.group, test.validDate, "metadata."+test.runID+".json"),
|
|
DataPackage: filepath.Join(store.root, "data-packages", test.group, test.validDate, "data_package."+test.runID+".yaml"),
|
|
Preparation: filepath.Join(store.root, "preflight", test.group, test.validDate, "prompt_preparation."+test.runID+".json"),
|
|
Execution: filepath.Join(store.root, "snapshots", test.group, test.validDate, "prompt_execution."+test.runID+".json"),
|
|
Notification: filepath.Join(store.root, "notifications", test.group, test.validDate, "distributor."+test.runID+".json"),
|
|
RenderedReport: filepath.Join(store.root, "reports", test.group, test.validDate, "report."+test.runID+".md"),
|
|
GeneratedTextRaw: filepath.Join(store.root, "snapshots", test.group, test.validDate, "generated_text_raw."+test.runID+".json"),
|
|
GeneratedText: filepath.Join(store.root, "snapshots", test.group, test.validDate, "generated_text."+test.runID+".json"),
|
|
RenderContext: filepath.Join(store.root, "snapshots", test.group, test.validDate, "render_context."+test.runID+".json"),
|
|
}
|
|
if paths != want {
|
|
t.Fatalf("Paths() = %#v, want %#v", paths, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPromptArtifactsAndMetadataRoundTrip(t *testing.T) {
|
|
store := newFilesystemTestStore(t)
|
|
resolved := resolveStateReport(t, report.Daily, "2026-05-29T05:00:00-05:00", "2026-05-29T12:00:00-05:00")
|
|
paths, err := store.Paths(resolved)
|
|
if err != nil {
|
|
t.Fatalf("Paths() error = %v", err)
|
|
}
|
|
preparation := preparationArtifactFor(resolved, paths)
|
|
preparationPath, err := store.SavePromptPreparation(context.Background(), resolved, preparation)
|
|
if err != nil {
|
|
t.Fatalf("SavePromptPreparation() error = %v", err)
|
|
}
|
|
execution := executionArtifactFor(resolved, paths)
|
|
executionPath, err := store.SavePromptExecution(context.Background(), resolved, execution)
|
|
if err != nil {
|
|
t.Fatalf("SavePromptExecution() error = %v", err)
|
|
}
|
|
loadedPreparation, err := store.LoadPromptPreparation(context.Background(), preparationPath)
|
|
if err != nil || loadedPreparation.Preparation == nil || loadedPreparation.Preparation.PromptHash != "prompt-hash" {
|
|
t.Fatalf("LoadPromptPreparation() = %#v, %v", loadedPreparation, err)
|
|
}
|
|
loadedExecution, err := store.LoadPromptExecution(context.Background(), executionPath)
|
|
if err != nil || loadedExecution.Provenance == nil || loadedExecution.Provenance.RunID != "provider-run" || loadedExecution.Validation == nil {
|
|
t.Fatalf("LoadPromptExecution() = %#v, %v", loadedExecution, err)
|
|
}
|
|
|
|
metadata := promptMetadataFor(resolved, paths)
|
|
metadata.PreparationPath = preparationPath
|
|
metadata.ExecutionPath = executionPath
|
|
metadata.GeneratedTextRawPath = paths.GeneratedTextRaw
|
|
metadataPath, err := store.SaveMetadata(context.Background(), metadata)
|
|
if err != nil {
|
|
t.Fatalf("SaveMetadata() error = %v", err)
|
|
}
|
|
data, err := os.ReadFile(metadataPath)
|
|
if err != nil {
|
|
t.Fatalf("read metadata: %v", err)
|
|
}
|
|
text := string(data)
|
|
if strings.Contains(text, "preflightPath") || strings.Contains(text, "generatedTextResultPath") || strings.Contains(text, "metadataPath") {
|
|
t.Fatalf("v2 metadata contains legacy or runtime aliases: %s", text)
|
|
}
|
|
loadedMetadata, loadedPath, err := store.LoadMetadataByRunID(context.Background(), metadata.RunID)
|
|
if err != nil || loadedPath != metadataPath || loadedMetadata.PreparationPath != preparationPath || loadedMetadata.ExecutionPath != executionPath {
|
|
t.Fatalf("LoadMetadataByRunID() = %#v, %q, %v", loadedMetadata, loadedPath, err)
|
|
}
|
|
}
|
|
|
|
func TestMetadataLegacyCompatibilityAndV2OnlyWrites(t *testing.T) {
|
|
legacy := Metadata{
|
|
SchemaVersion: MetadataSchemaVersionV1, RunID: "legacy-run", ReportID: report.ID("three_day"),
|
|
PromptID: "weather.three_day", ModuleSnapshotPath: "/archive/modules.json", DataPackagePath: "/archive/data.yaml",
|
|
PreflightPath: "/archive/render.json", GeneratedTextResultPath: "/archive/result.json",
|
|
}
|
|
data, err := json.Marshal(legacy)
|
|
if err != nil {
|
|
t.Fatalf("Marshal() error = %v", err)
|
|
}
|
|
text := string(data)
|
|
if !strings.Contains(text, "preflightPath") || !strings.Contains(text, "generatedTextResultPath") || strings.Contains(text, "preparationPath") || strings.Contains(text, "executionPath") {
|
|
t.Fatalf("v1 metadata wire fields = %s", text)
|
|
}
|
|
var decoded Metadata
|
|
if err := json.Unmarshal(data, &decoded); err != nil {
|
|
t.Fatalf("Unmarshal() error = %v", err)
|
|
}
|
|
if decoded.PreparationPath != legacy.PreflightPath || decoded.ExecutionPath != legacy.GeneratedTextResultPath {
|
|
t.Fatalf("normalized compatibility aliases = %#v", decoded)
|
|
}
|
|
remarshaled, err := json.Marshal(decoded)
|
|
if err != nil || !strings.Contains(string(remarshaled), "preflightPath") || strings.Contains(string(remarshaled), "preparationPath") {
|
|
t.Fatalf("remarshaled v1 metadata = %s, %v", remarshaled, err)
|
|
}
|
|
if err := json.Unmarshal([]byte(`{"schemaVersion":"weatherreporter.metadata.v99"}`), &decoded); err == nil {
|
|
t.Fatal("Unmarshal() error = nil, want unknown schema rejection")
|
|
}
|
|
|
|
store := newFilesystemTestStore(t)
|
|
legacy.MetadataPath = filepath.Join(store.root, "snapshots", "legacy", "metadata.legacy-run.json")
|
|
if _, err := store.SaveMetadata(context.Background(), legacy); err == nil {
|
|
t.Fatal("SaveMetadata(v1) error = nil, want v2-only write rejection")
|
|
}
|
|
}
|
|
|
|
func TestReportDiscoveryAndArtifactInspection(t *testing.T) {
|
|
store := newFilesystemTestStore(t)
|
|
older := resolveStateReport(t, report.Daily, "2026-05-29T05:00:00-05:00", "2026-05-29T12:00:00-05:00")
|
|
newer := resolveStateReport(t, report.Today, "2026-05-29T08:00:00-05:00", "")
|
|
olderPaths := saveStateMetadata(t, store, older)
|
|
newerPaths := saveStateMetadata(t, store, newer)
|
|
|
|
snapshot, err := module.NewSnapshot([]module.Output{{ID: module.Metadata, StanzaName: "metadata", Value: map[string]any{"run_id": older.Metadata().RunID}}})
|
|
if err != nil {
|
|
t.Fatalf("NewSnapshot() error = %v", err)
|
|
}
|
|
modulePath, err := store.SaveModuleSnapshot(context.Background(), older, snapshot)
|
|
if err != nil {
|
|
t.Fatalf("SaveModuleSnapshot() error = %v", err)
|
|
}
|
|
pkg, err := promptinput.Build(promptinput.BuildRequest{
|
|
Metadata: promptinput.Metadata{
|
|
RunID: older.Metadata().RunID, ReportID: older.Definition.ID, PromptID: older.Definition.PromptID,
|
|
GeneratedAt: older.GeneratedAt, Timezone: older.Timezone, ValidPeriod: older.ValidPeriod,
|
|
},
|
|
Modules: snapshot,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Build() error = %v", err)
|
|
}
|
|
dataPath, err := store.SaveDataPackage(context.Background(), older, pkg)
|
|
if err != nil {
|
|
t.Fatalf("SaveDataPackage() error = %v", err)
|
|
}
|
|
loadedSnapshot, err := store.LoadModuleSnapshot(context.Background(), modulePath)
|
|
if err != nil || len(loadedSnapshot.Outputs) != 1 {
|
|
t.Fatalf("LoadModuleSnapshot() = %#v, %v", loadedSnapshot, err)
|
|
}
|
|
loadedPackage, err := store.LoadDataPackage(context.Background(), dataPath)
|
|
if err != nil || loadedPackage.RunID != older.Metadata().RunID {
|
|
t.Fatalf("LoadDataPackage() = %#v, %v", loadedPackage, err)
|
|
}
|
|
|
|
records, err := store.ListReports(context.Background(), 0)
|
|
if err != nil || len(records) != 2 {
|
|
t.Fatalf("ListReports() = %#v, %v", records, err)
|
|
}
|
|
if records[0].RunID != newer.Metadata().RunID || records[0].MetadataPath != newerPaths.Metadata || records[1].MetadataPath != olderPaths.Metadata {
|
|
t.Fatalf("ordered report records = %#v", records)
|
|
}
|
|
loadedMetadata, loadedPath, err := store.LoadMetadataByRunID(context.Background(), older.Metadata().RunID)
|
|
if err != nil || loadedPath != olderPaths.Metadata || len(loadedMetadata.Sources) != 1 || loadedMetadata.Sources[0].Name != "weather-api" {
|
|
t.Fatalf("LoadMetadataByRunID() = %#v, %q, %v", loadedMetadata, loadedPath, err)
|
|
}
|
|
}
|
|
|
|
func TestListReportsRetainsHistoricalV1ReportIDs(t *testing.T) {
|
|
store := newFilesystemTestStore(t)
|
|
for i, id := range []report.ID{"three_day", "weekend", "storm"} {
|
|
generatedAt := time.Date(2026, 5, 20+i, 12, 0, 0, 0, time.UTC)
|
|
metadata := Metadata{
|
|
SchemaVersion: MetadataSchemaVersionV1, RunID: "historical-" + string(id), ReportID: id,
|
|
PromptID: "weather." + string(id), GeneratedAt: generatedAt, Timezone: "UTC",
|
|
ValidPeriod: timeutil.Period{Start: generatedAt, End: generatedAt.Add(24 * time.Hour)},
|
|
ModuleSnapshotPath: "/archive/modules.json", DataPackagePath: "/archive/data.yaml",
|
|
PreflightPath: "/archive/render.json", GeneratedTextResultPath: "/archive/result.json",
|
|
}
|
|
path := filepath.Join(store.root, "snapshots", string(id), "2026-05-20", "metadata."+metadata.RunID+".json")
|
|
writeJSONFixture(t, path, metadata)
|
|
}
|
|
records, err := store.ListReports(context.Background(), 0)
|
|
if err != nil || len(records) != 3 {
|
|
t.Fatalf("ListReports() = %#v, %v", records, err)
|
|
}
|
|
for _, record := range records {
|
|
if record.ReportID != "three_day" && record.ReportID != "weekend" && record.ReportID != "storm" {
|
|
t.Fatalf("unexpected historical report record: %#v", record)
|
|
}
|
|
metadata, path, err := store.LoadMetadataByRunID(context.Background(), record.RunID)
|
|
if err != nil || path != record.MetadataPath || metadata.PreparationPath != "/archive/render.json" || metadata.ExecutionPath != "/archive/result.json" {
|
|
t.Fatalf("LoadMetadataByRunID(%q) = %#v, %q, %v", record.RunID, metadata, path, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFilesystemWritesAreAtomicAndRejectUnsafePaths(t *testing.T) {
|
|
store := newFilesystemTestStore(t)
|
|
resolved := resolveStateReport(t, report.Hourly, "2026-05-29T05:00:00-05:00", "")
|
|
path, err := store.SaveGeneratedTextRaw(context.Background(), resolved, []byte(`{"value":"first"}`))
|
|
if err != nil {
|
|
t.Fatalf("first SaveGeneratedTextRaw() error = %v", err)
|
|
}
|
|
if _, err := store.SaveGeneratedTextRaw(context.Background(), resolved, []byte(`{"value":"second"}`)); err != nil {
|
|
t.Fatalf("second SaveGeneratedTextRaw() error = %v", err)
|
|
}
|
|
data, err := os.ReadFile(path)
|
|
if err != nil || string(data) != `{"value":"second"}` {
|
|
t.Fatalf("atomic replacement = %q, %v", data, err)
|
|
}
|
|
entries, err := os.ReadDir(filepath.Dir(path))
|
|
if err != nil || len(entries) != 1 || entries[0].Name() != filepath.Base(path) {
|
|
t.Fatalf("artifact directory after atomic write = %#v, %v", entries, err)
|
|
}
|
|
|
|
metadata := promptMetadataFor(resolved, mustStatePaths(t, store, resolved))
|
|
metadata.PreparationPath = "/saved/preparation.json"
|
|
metadata.MetadataPath = filepath.Join(t.TempDir(), "outside.json")
|
|
if _, err := store.SaveMetadata(context.Background(), metadata); err == nil {
|
|
t.Fatal("SaveMetadata(outside workspace) error = nil")
|
|
}
|
|
|
|
cfg := config.Defaults().Workspace
|
|
cfg.Root = t.TempDir()
|
|
cfg.SnapshotsDir = "../snapshots"
|
|
if _, err := NewFilesystemStore(cfg); err == nil {
|
|
t.Fatal("NewFilesystemStore(unsafe directory) error = nil")
|
|
}
|
|
unsafeResolved := resolved
|
|
unsafeResolved.Definition.ID = report.ID("hourly/bad")
|
|
if _, err := store.Paths(unsafeResolved); err == nil {
|
|
t.Fatal("Paths(unsafe run id) error = nil")
|
|
}
|
|
}
|
|
|
|
func TestFindPriorSnapshotForSupportedReports(t *testing.T) {
|
|
tests := []struct {
|
|
id report.ID
|
|
firstNow string
|
|
secondNow string
|
|
date string
|
|
wantPrior bool
|
|
}{
|
|
{report.Daily, "2026-05-29T05:00:00-05:00", "2026-05-29T08:00:00-05:00", "2026-05-29T12:00:00-05:00", true},
|
|
{report.Today, "2026-05-29T05:00:00-05:00", "2026-05-29T08:00:00-05:00", "", true},
|
|
{report.Tomorrow, "2026-05-29T17:00:00-05:00", "2026-05-29T18:00:00-05:00", "", true},
|
|
{report.Hourly, "2026-05-29T05:00:00-05:00", "2026-05-29T06:00:00-05:00", "", false},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(string(test.id), func(t *testing.T) {
|
|
store := newFilesystemTestStore(t)
|
|
first := resolveStateReport(t, test.id, test.firstNow, test.date)
|
|
second := resolveStateReport(t, test.id, test.secondNow, test.date)
|
|
paths := saveStateMetadata(t, store, first)
|
|
prior, err := store.FindPriorSnapshot(context.Background(), second)
|
|
if err != nil {
|
|
t.Fatalf("FindPriorSnapshot() error = %v", err)
|
|
}
|
|
if !test.wantPrior && prior != nil {
|
|
t.Fatalf("FindPriorSnapshot() = %#v, want nil", prior)
|
|
}
|
|
if test.wantPrior && (prior == nil || prior.Metadata.RunID != first.Metadata().RunID || prior.ModuleSnapshotPath != paths.ModuleSnapshot) {
|
|
t.Fatalf("FindPriorSnapshot() = %#v, want run %q", prior, first.Metadata().RunID)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func newFilesystemTestStore(t *testing.T) *FilesystemStore {
|
|
t.Helper()
|
|
cfg := config.Defaults().Workspace
|
|
cfg.Root = t.TempDir()
|
|
store, err := NewFilesystemStore(cfg)
|
|
if err != nil {
|
|
t.Fatalf("NewFilesystemStore() error = %v", err)
|
|
}
|
|
return store
|
|
}
|
|
|
|
func resolveStateReport(t *testing.T, id report.ID, nowValue, dateValue string) report.Resolved {
|
|
t.Helper()
|
|
location, err := time.LoadLocation("America/Chicago")
|
|
if err != nil {
|
|
t.Fatalf("LoadLocation() error = %v", err)
|
|
}
|
|
now, err := time.Parse(time.RFC3339, nowValue)
|
|
if err != nil {
|
|
t.Fatalf("parse now: %v", err)
|
|
}
|
|
req := report.ResolveRequest{Now: now, Location: location}
|
|
if dateValue != "" {
|
|
req.Date, err = time.Parse(time.RFC3339, dateValue)
|
|
if err != nil {
|
|
t.Fatalf("parse date: %v", err)
|
|
}
|
|
}
|
|
resolved, err := report.DefaultRegistry().Resolve(id, req)
|
|
if err != nil {
|
|
t.Fatalf("Resolve() error = %v", err)
|
|
}
|
|
return resolved
|
|
}
|
|
|
|
func mustStatePaths(t *testing.T, store *FilesystemStore, resolved report.Resolved) ArtifactPaths {
|
|
t.Helper()
|
|
paths, err := store.Paths(resolved)
|
|
if err != nil {
|
|
t.Fatalf("Paths() error = %v", err)
|
|
}
|
|
return paths
|
|
}
|
|
|
|
func promptMetadataFor(resolved report.Resolved, paths ArtifactPaths) Metadata {
|
|
metadata := BuildPromptMetadataFromBriefingMetadata(resolved, briefing.Metadata{
|
|
Sources: []briefing.SourceMetadata{{Name: "weather-api", FetchedAt: resolved.GeneratedAt}},
|
|
SourceWarnings: []weatherdata.SourceWarning{},
|
|
}, ArtifactPaths{ModuleSnapshot: paths.ModuleSnapshot, Metadata: paths.Metadata, DataPackage: paths.DataPackage})
|
|
return metadata
|
|
}
|
|
|
|
func saveStateMetadata(t *testing.T, store *FilesystemStore, resolved report.Resolved) ArtifactPaths {
|
|
t.Helper()
|
|
paths := mustStatePaths(t, store, resolved)
|
|
metadata := promptMetadataFor(resolved, paths)
|
|
metadata.PreparationPath = paths.Preparation
|
|
if _, err := store.SaveMetadata(context.Background(), metadata); err != nil {
|
|
t.Fatalf("SaveMetadata() error = %v", err)
|
|
}
|
|
return paths
|
|
}
|
|
|
|
func preparationArtifactFor(resolved report.Resolved, paths ArtifactPaths) PromptPreparationArtifact {
|
|
artifact := validPreparationArtifact()
|
|
metadata := resolved.Metadata()
|
|
artifact.ReportID, artifact.RunID = metadata.ReportID, metadata.RunID
|
|
artifact.PromptID, artifact.PromptVersion = resolved.Definition.PromptID, resolved.Definition.PromptVersion
|
|
artifact.DataPackagePath = paths.DataPackage
|
|
artifact.Preparation.PromptID, artifact.Preparation.PromptVersion = artifact.PromptID, artifact.PromptVersion
|
|
artifact.Preparation.PromptHash = "prompt-hash"
|
|
return artifact
|
|
}
|
|
|
|
func validPreparationArtifact() PromptPreparationArtifact {
|
|
started := time.Date(2026, 5, 29, 15, 0, 0, 0, time.UTC)
|
|
return PromptPreparationArtifact{
|
|
SchemaVersion: PromptPreparationSchemaVersion, Status: PromptPreparationSucceeded,
|
|
ReportID: report.Daily, RunID: "weatherreporter-run", PromptID: "weather.daily_generated_text", PromptVersion: "2.0.0",
|
|
DataPackagePath: "/workspace/data.yaml", Preparation: &promptexec.Preparation{PromptID: "weather.daily_generated_text", PromptVersion: "2.0.0"},
|
|
StartedAt: started, EndedAt: started.Add(time.Second), Duration: time.Second,
|
|
}
|
|
}
|
|
|
|
func executionArtifactFor(resolved report.Resolved, paths ArtifactPaths) PromptExecutionArtifact {
|
|
artifact := validExecutionArtifact()
|
|
metadata := resolved.Metadata()
|
|
artifact.ReportID, artifact.RunID = metadata.ReportID, metadata.RunID
|
|
artifact.PromptID, artifact.PromptVersion = resolved.Definition.PromptID, resolved.Definition.PromptVersion
|
|
artifact.Provenance.PromptID, artifact.Provenance.PromptVersion = artifact.PromptID, artifact.PromptVersion
|
|
artifact.Paths.RawOutputPath = paths.GeneratedTextRaw
|
|
return artifact
|
|
}
|
|
|
|
func validExecutionArtifact() PromptExecutionArtifact {
|
|
started := time.Date(2026, 5, 29, 15, 0, 0, 0, time.UTC)
|
|
validation := promptexec.NewValidation(promptexec.ValidationPassed, "json_schema", "daily.generated_text.schema.json", nil)
|
|
return PromptExecutionArtifact{
|
|
SchemaVersion: PromptExecutionSchemaVersion, Status: PromptExecutionSucceeded,
|
|
ReportID: report.Daily, RunID: "weatherreporter-run", PromptID: "weather.daily_generated_text", PromptVersion: "2.0.0",
|
|
Provenance: &PromptExecutionProvenance{RunID: "provider-run", PromptID: "weather.daily_generated_text", PromptVersion: "2.0.0", PromptHash: "prompt-hash", RenderedPromptHash: "rendered-hash", ProfileID: "profile", BackendID: "backend", ModelName: "model", StartedAt: started, EndedAt: started.Add(time.Second), Duration: time.Second},
|
|
Validation: &validation, StartedAt: started, EndedAt: started.Add(time.Second), Duration: time.Second,
|
|
}
|
|
}
|
|
|
|
func writeJSONFixture(t *testing.T, path string, value any) {
|
|
t.Helper()
|
|
data, err := json.Marshal(value)
|
|
if err != nil {
|
|
t.Fatalf("marshal fixture: %v", err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
|
t.Fatalf("create fixture directory: %v", err)
|
|
}
|
|
if err := os.WriteFile(path, data, 0o600); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
}
|