274 lines
10 KiB
Go
274 lines
10 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/eric/distributor/internal/config"
|
|
"gitea.maximumdirect.net/eric/distributor/internal/state"
|
|
"gitea.maximumdirect.net/eric/distributor/internal/storage"
|
|
"gitea.maximumdirect.net/eric/distributor/internal/storage/fake"
|
|
"gitea.maximumdirect.net/eric/distributor/internal/testutil"
|
|
)
|
|
|
|
func TestReconcileStateDryRunReportsMissingManagedOutputsWithoutRewrite(t *testing.T) {
|
|
t.Skip("catalog reconcile-state execution is covered by the catalog maintenance work")
|
|
backend := fake.New()
|
|
cfg := reconcileStateS3Config(t)
|
|
manifest := testutil.ValidManifest(testutil.BundleOptions{})
|
|
testutil.WriteFakeDestinationState(t, backend, "", manifest, testutil.DestinationStateOptions{})
|
|
if err := backend.DeleteManagedOutputs(context.Background(), "", []string{"summary.txt"}, storage.DeleteOptions{}); err != nil {
|
|
t.Fatalf("delete managed output: %v", err)
|
|
}
|
|
testutil.WriteFakeFile(t, backend, "extra.txt", "unmanaged")
|
|
|
|
report, err := reconcileStateConfigWithBackendFactory(context.Background(), cfg, ReconcileStateOptions{
|
|
PipelineID: "reports",
|
|
DestinationID: "archive",
|
|
DryRun: true,
|
|
}, fakeBackendFactoryProvider(t, map[string]storage.Backend{"s3:reports": backend}))
|
|
if err != nil {
|
|
t.Fatalf("reconcileStateConfigWithBackendFactory() error = %v", err)
|
|
}
|
|
if !report.WouldChange || report.Changed {
|
|
t.Fatalf("report changed=%t would_change=%t, want dry-run pending change", report.Changed, report.WouldChange)
|
|
}
|
|
if got := reportPathList(report.MissingManagedOutputs); got != "summary.txt" {
|
|
t.Fatalf("missing outputs = %q, want summary.txt", got)
|
|
}
|
|
if got := entryPathList(report.UnmanagedEntries); got != "extra.txt" {
|
|
t.Fatalf("unmanaged entries = %q, want extra.txt", got)
|
|
}
|
|
destinationState := readFakeSingleOwnerState(t, backend)
|
|
if got := strings.Join(state.ManagedOutputPaths(destinationState), ","); got != "report.md,summary.txt" {
|
|
t.Fatalf("state outputs = %q, want original outputs", got)
|
|
}
|
|
}
|
|
|
|
func TestReconcileStateApplyRemovesMissingRecordsAndPreservesUnmanagedFiles(t *testing.T) {
|
|
t.Skip("catalog reconcile-state execution is covered by the catalog maintenance work")
|
|
backend := fake.New()
|
|
cfg := reconcileStateS3Config(t)
|
|
manifest := testutil.ValidManifest(testutil.BundleOptions{})
|
|
testutil.WriteFakeDestinationState(t, backend, "", manifest, testutil.DestinationStateOptions{})
|
|
if err := backend.DeleteManagedOutputs(context.Background(), "", []string{"summary.txt"}, storage.DeleteOptions{}); err != nil {
|
|
t.Fatalf("delete managed output: %v", err)
|
|
}
|
|
testutil.WriteFakeFile(t, backend, "extra.txt", "unmanaged")
|
|
|
|
report, err := reconcileStateConfigWithBackendFactory(context.Background(), cfg, ReconcileStateOptions{
|
|
PipelineID: "reports",
|
|
DestinationID: "archive",
|
|
}, fakeBackendFactoryProvider(t, map[string]storage.Backend{"s3:reports": backend}))
|
|
if err != nil {
|
|
t.Fatalf("reconcileStateConfigWithBackendFactory() error = %v", err)
|
|
}
|
|
if !report.Changed || report.WouldChange {
|
|
t.Fatalf("report changed=%t would_change=%t, want applied change", report.Changed, report.WouldChange)
|
|
}
|
|
destinationState := readFakeSingleOwnerState(t, backend)
|
|
if err := state.Validate(destinationState); err != nil {
|
|
t.Fatalf("Validate() repaired state error = %v", err)
|
|
}
|
|
if got := strings.Join(state.ManagedOutputPaths(destinationState), ","); got != "report.md" {
|
|
t.Fatalf("state outputs = %q, want report.md", got)
|
|
}
|
|
testutil.AssertFakeFile(t, backend, "extra.txt", "unmanaged")
|
|
}
|
|
|
|
func TestReconcileStateInvalidStateFailsWithoutRewrite(t *testing.T) {
|
|
backend := fake.New()
|
|
cfg := reconcileStateS3Config(t)
|
|
invalid := `{"schema_version":2,"pipeline_id":"reports"}`
|
|
testutil.WriteFakeFile(t, backend, storage.StateFileName, invalid)
|
|
|
|
_, err := reconcileStateConfigWithBackendFactory(context.Background(), cfg, ReconcileStateOptions{
|
|
PipelineID: "reports",
|
|
DestinationID: "archive",
|
|
}, fakeBackendFactoryProvider(t, map[string]storage.Backend{"s3:reports": backend}))
|
|
if err == nil {
|
|
t.Fatal("reconcileStateConfigWithBackendFactory() error = nil, want invalid state error")
|
|
}
|
|
data, readErr := backend.ReadFile(context.Background(), storage.StateFileName)
|
|
if readErr != nil {
|
|
t.Fatalf("read invalid state: %v", readErr)
|
|
}
|
|
if string(data) != invalid {
|
|
t.Fatalf("state data = %q, want original invalid data", data)
|
|
}
|
|
}
|
|
|
|
func TestReconcileStateSharedRootOwnerScopeRepairsCurrentOwnerOnly(t *testing.T) {
|
|
t.Skip("catalog reconcile-state execution is covered by the catalog maintenance work")
|
|
backend := fake.New()
|
|
cfg := reconcileStateS3Config(t)
|
|
sharedRoot := reconcileSharedRootFixture(t)
|
|
writeFakeSharedRootStateForApp(t, backend, sharedRoot)
|
|
if err := backend.DeleteManagedOutputs(context.Background(), "", []string{"report.md", "report.html"}, storage.DeleteOptions{}); err != nil {
|
|
t.Fatalf("delete managed outputs: %v", err)
|
|
}
|
|
|
|
report, err := reconcileStateConfigWithBackendFactory(context.Background(), cfg, ReconcileStateOptions{
|
|
PipelineID: "reports",
|
|
DestinationID: "archive",
|
|
}, fakeBackendFactoryProvider(t, map[string]storage.Backend{"s3:reports": backend}))
|
|
if err != nil {
|
|
t.Fatalf("reconcileStateConfigWithBackendFactory() error = %v", err)
|
|
}
|
|
if !report.Changed {
|
|
t.Fatal("report changed = false, want true")
|
|
}
|
|
repaired := readFakeSharedRootStateForApp(t, backend)
|
|
if got := strings.Join(repaired.AllManagedOutputPaths(), ","); got != "report.html" {
|
|
t.Fatalf("shared-root outputs = %q, want other owner output preserved", got)
|
|
}
|
|
}
|
|
|
|
func TestReconcileStateSharedRootAllOwnersRepairsEveryOwner(t *testing.T) {
|
|
t.Skip("catalog reconcile-state execution is covered by the catalog maintenance work")
|
|
backend := fake.New()
|
|
cfg := reconcileStateS3Config(t)
|
|
sharedRoot := reconcileSharedRootFixture(t)
|
|
writeFakeSharedRootStateForApp(t, backend, sharedRoot)
|
|
if err := backend.DeleteManagedOutputs(context.Background(), "", []string{"report.md", "report.html"}, storage.DeleteOptions{}); err != nil {
|
|
t.Fatalf("delete managed outputs: %v", err)
|
|
}
|
|
|
|
report, err := reconcileStateConfigWithBackendFactory(context.Background(), cfg, ReconcileStateOptions{
|
|
PipelineID: "reports",
|
|
DestinationID: "archive",
|
|
AllOwners: true,
|
|
}, fakeBackendFactoryProvider(t, map[string]storage.Backend{"s3:reports": backend}))
|
|
if err != nil {
|
|
t.Fatalf("reconcileStateConfigWithBackendFactory() error = %v", err)
|
|
}
|
|
if !report.Changed || report.CheckedCount != 2 {
|
|
t.Fatalf("report changed=%t checked=%d, want all-owner repair", report.Changed, report.CheckedCount)
|
|
}
|
|
repaired := readFakeSharedRootStateForApp(t, backend)
|
|
if got := repaired.AllManagedOutputPaths(); len(got) != 0 {
|
|
t.Fatalf("shared-root outputs = %#v, want none", got)
|
|
}
|
|
}
|
|
|
|
func reconcileStateS3Config(t *testing.T) config.Config {
|
|
t.Helper()
|
|
cfg := config.Config{Pipelines: []config.Pipeline{{
|
|
ID: "reports",
|
|
Source: config.Backend{Backend: config.BackendLocal, Path: t.TempDir()},
|
|
Destinations: []config.Destination{{
|
|
ID: "archive",
|
|
Backend: config.BackendS3,
|
|
Bucket: "reports",
|
|
}},
|
|
}}}
|
|
config.ApplyDefaults(&cfg)
|
|
return cfg
|
|
}
|
|
|
|
func readFakeSingleOwnerState(t *testing.T, backend *fake.Backend) state.DistributorState {
|
|
t.Helper()
|
|
data, err := backend.ReadFile(context.Background(), storage.StateFileName)
|
|
if err != nil {
|
|
t.Fatalf("read state: %v", err)
|
|
}
|
|
destinationState, err := state.Parse(data)
|
|
if err != nil {
|
|
t.Fatalf("parse state: %v", err)
|
|
}
|
|
return destinationState
|
|
}
|
|
|
|
func writeFakeSharedRootStateForApp(t *testing.T, backend *fake.Backend, sharedRoot state.SharedRootState) {
|
|
t.Helper()
|
|
data, err := json.MarshalIndent(sharedRoot, "", " ")
|
|
if err != nil {
|
|
t.Fatalf("marshal shared-root state: %v", err)
|
|
}
|
|
testutil.WriteFakeFile(t, backend, storage.StateFileName, string(append(data, '\n')))
|
|
for _, output := range sharedRoot.Outputs {
|
|
testutil.WriteFakeFile(t, backend, output.Path, "old")
|
|
}
|
|
}
|
|
|
|
func readFakeSharedRootStateForApp(t *testing.T, backend *fake.Backend) state.SharedRootState {
|
|
t.Helper()
|
|
data, err := backend.ReadFile(context.Background(), storage.StateFileName)
|
|
if err != nil {
|
|
t.Fatalf("read shared-root state: %v", err)
|
|
}
|
|
sharedRoot, err := state.ParseSharedRoot(data)
|
|
if err != nil {
|
|
t.Fatalf("parse shared-root state: %v", err)
|
|
}
|
|
return sharedRoot
|
|
}
|
|
|
|
func reconcileSharedRootFixture(t *testing.T) state.SharedRootState {
|
|
t.Helper()
|
|
source := testutil.ValidManifest(testutil.BundleOptions{})
|
|
htmlSource := source
|
|
createdAt := time.Date(2026, 5, 30, 11, 12, 0, 0, time.UTC)
|
|
return state.SharedRootState{
|
|
SchemaVersion: state.SharedRootSchemaVersion,
|
|
DistributorVersion: "test",
|
|
CreatedAt: createdAt,
|
|
UpdatedAt: createdAt,
|
|
State: state.StatePolicy{Mode: state.StateModeSharedRoot},
|
|
Owners: []state.OwnerRecord{{
|
|
Scope: state.CurrentOwnerScope("reports", "archive"),
|
|
Reconciliation: state.ReconciliationPolicy{Mode: config.ReconciliationModeReplace},
|
|
Source: state.SourceState{Manifest: source},
|
|
}, {
|
|
Scope: state.CurrentOwnerScope("reports", "html"),
|
|
Reconciliation: state.ReconciliationPolicy{Mode: config.ReconciliationModeMerge},
|
|
Source: state.SourceState{Manifest: htmlSource},
|
|
}},
|
|
Outputs: []state.SharedRootOutputFile{{
|
|
Path: "report.md",
|
|
Kind: state.OutputKindSource,
|
|
SourcePath: "report.md",
|
|
SHA256: source.Files[0].SHA256,
|
|
Size: source.Files[0].Size,
|
|
Owner: state.CurrentOwnerScope("reports", "archive"),
|
|
SourceID: source.ID,
|
|
SourceDigest: source.Digest,
|
|
SourceCreated: source.Created,
|
|
CreatedAt: createdAt,
|
|
UpdatedAt: createdAt,
|
|
}, {
|
|
Path: "report.html",
|
|
Kind: state.OutputKindGenerated,
|
|
SourcePath: "report.md",
|
|
Transform: "markdown_to_html",
|
|
SHA256: "sha256:" + strings.Repeat("a", 64),
|
|
Size: 128,
|
|
Owner: state.CurrentOwnerScope("reports", "html"),
|
|
SourceID: htmlSource.ID,
|
|
SourceDigest: htmlSource.Digest,
|
|
SourceCreated: htmlSource.Created,
|
|
CreatedAt: createdAt,
|
|
UpdatedAt: createdAt,
|
|
}},
|
|
}
|
|
}
|
|
|
|
func reportPathList(paths []ReconcileStatePath) string {
|
|
values := make([]string, 0, len(paths))
|
|
for _, path := range paths {
|
|
values = append(values, path.Path)
|
|
}
|
|
return strings.Join(values, ",")
|
|
}
|
|
|
|
func entryPathList(entries []ReconcileStateEntry) string {
|
|
values := make([]string, 0, len(entries))
|
|
for _, entry := range entries {
|
|
values = append(values, entry.Path)
|
|
}
|
|
return strings.Join(values, ",")
|
|
}
|