246 lines
7.4 KiB
Go
246 lines
7.4 KiB
Go
package state
|
|
|
|
import (
|
|
"encoding/json"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/eric/distributor/internal/bundle"
|
|
)
|
|
|
|
func TestParseValidState(t *testing.T) {
|
|
state, err := Parse([]byte(validStateJSON(t)))
|
|
if err != nil {
|
|
t.Fatalf("Parse() error = %v", err)
|
|
}
|
|
if state.SchemaVersion != SchemaVersion {
|
|
t.Fatalf("schema version = %d, want %d", state.SchemaVersion, SchemaVersion)
|
|
}
|
|
if state.PipelineID != "reports" || state.DestinationID != "archive" {
|
|
t.Fatalf("identity = %q/%q", state.PipelineID, state.DestinationID)
|
|
}
|
|
if got, want := state.PublishedAtString(), "2026-05-30T11:12:00Z"; got != want {
|
|
t.Fatalf("PublishedAtString() = %q, want %q", got, want)
|
|
}
|
|
if got, want := len(state.Outputs), 1; got != want {
|
|
t.Fatalf("output count = %d, want %d", got, want)
|
|
}
|
|
}
|
|
|
|
func TestParseNormalizesPublishedAtOffset(t *testing.T) {
|
|
body := strings.Replace(validStateJSON(t), `"published_at": "2026-05-30T11:12:00Z"`, `"published_at": "2026-05-30T13:12:00+02:00"`, 1)
|
|
state, err := Parse([]byte(body))
|
|
if err != nil {
|
|
t.Fatalf("Parse() error = %v", err)
|
|
}
|
|
if got, want := state.PublishedAtString(), "2026-05-30T11:12:00Z"; got != want {
|
|
t.Fatalf("PublishedAtString() = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestParseRejectsMissingFields(t *testing.T) {
|
|
tests := map[string]string{
|
|
"schema_version": `"schema_version"`,
|
|
"pipeline_id": `"pipeline_id"`,
|
|
"destination_id": `"destination_id"`,
|
|
"published_at": `"published_at"`,
|
|
"source": `"source"`,
|
|
"outputs": `"outputs"`,
|
|
}
|
|
for name, field := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
body := strings.Replace(validStateJSON(t), field, `"missing_`+name+`"`, 1)
|
|
_, err := Parse([]byte(body))
|
|
assertStateErrorContains(t, err, "required")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseRejectsInvalidSchemaVersion(t *testing.T) {
|
|
body := strings.Replace(validStateJSON(t), `"schema_version": 1`, `"schema_version": 2`, 1)
|
|
_, err := Parse([]byte(body))
|
|
assertStateErrorContains(t, err, "schema_version must be 1")
|
|
}
|
|
|
|
func TestParseRejectsInvalidEmbeddedManifest(t *testing.T) {
|
|
body := validStateWithManifestJSON(t, strings.Replace(manifestJSON(t), `"schema_version": 1`, `"schema_version": 2`, 1))
|
|
_, err := Parse([]byte(body))
|
|
assertStateErrorContains(t, err, "source.manifest")
|
|
}
|
|
|
|
func TestValidateRejectsInvalidEmbeddedManifest(t *testing.T) {
|
|
tests := map[string]func(bundle.Manifest) bundle.Manifest{
|
|
"schema version": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.SchemaVersion = 2
|
|
return manifest
|
|
},
|
|
"empty id": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.ID = ""
|
|
return manifest
|
|
},
|
|
"bad digest": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.Digest = "SHA256:099b205780d2b050024868399961b05731729a548d5d6329c7b06a6740dd75fe"
|
|
return manifest
|
|
},
|
|
"zero created": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.Created = time.Time{}
|
|
return manifest
|
|
},
|
|
"empty files": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.Files = nil
|
|
manifest.Digest = bundle.BundleDigest(manifest.Files)
|
|
return manifest
|
|
},
|
|
"unsafe path": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.Files[0].Path = "../report.md"
|
|
manifest.Digest = bundle.BundleDigest(manifest.Files)
|
|
return manifest
|
|
},
|
|
"duplicate path": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.Files[1].Path = manifest.Files[0].Path
|
|
manifest.Digest = bundle.BundleDigest(manifest.Files)
|
|
return manifest
|
|
},
|
|
"negative size": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.Files[0].Size = -1
|
|
manifest.Digest = bundle.BundleDigest(manifest.Files)
|
|
return manifest
|
|
},
|
|
"digest mismatch": func(manifest bundle.Manifest) bundle.Manifest {
|
|
manifest.Digest = "sha256:0000000000000000000000000000000000000000000000000000000000000000"
|
|
return manifest
|
|
},
|
|
}
|
|
for name, mutate := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
source := mutate(validManifest(t))
|
|
state := *withState(t, validManifest(t), func(*DistributorState) {})
|
|
state.Source.Manifest = source
|
|
err := Validate(state)
|
|
assertStateErrorContains(t, err, "source.manifest")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseRejectsInvalidOutputMetadata(t *testing.T) {
|
|
source := validManifest(t)
|
|
tests := map[string]func(*DistributorState){
|
|
"unsafe path": func(s *DistributorState) {
|
|
s.Outputs[0].Path = "../report.md"
|
|
},
|
|
"invalid kind": func(s *DistributorState) {
|
|
s.Outputs[0].Kind = "other"
|
|
},
|
|
"invalid source": func(s *DistributorState) {
|
|
s.Outputs[0].SourcePath = "../report.md"
|
|
},
|
|
"generated missing": func(s *DistributorState) {
|
|
s.Outputs[0].Kind = OutputKindGenerated
|
|
},
|
|
"invalid digest": func(s *DistributorState) {
|
|
s.Outputs[0].SHA256 = "SHA256:3640fd37140ee4d2e0e93e78834f232ea67a50e7bc6279203690cc7de1975fa6"
|
|
},
|
|
"negative size": func(s *DistributorState) {
|
|
s.Outputs[0].Size = -1
|
|
},
|
|
}
|
|
for name, mutate := range tests {
|
|
t.Run(name, func(t *testing.T) {
|
|
state := *withState(t, source, mutate)
|
|
err := Validate(state)
|
|
if err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseRejectsMalformedPublishedTimestamp(t *testing.T) {
|
|
body := strings.Replace(validStateJSON(t), `"published_at": "2026-05-30T11:12:00Z"`, `"published_at": "May 30"`, 1)
|
|
_, err := Parse([]byte(body))
|
|
assertStateErrorContains(t, err, "published_at must be RFC3339")
|
|
}
|
|
|
|
func TestMarshalNormalizesPublishedAtUTC(t *testing.T) {
|
|
source := validManifest(t)
|
|
state := DistributorState{
|
|
SchemaVersion: SchemaVersion,
|
|
PipelineID: "reports",
|
|
DestinationID: "archive",
|
|
PublishedAt: time.Date(2026, 5, 30, 13, 12, 0, 0, time.FixedZone("offset", 2*60*60)),
|
|
Source: SourceState{Manifest: source},
|
|
Outputs: []OutputFile{{
|
|
Path: "report.md",
|
|
Kind: OutputKindSource,
|
|
SourcePath: "report.md",
|
|
SHA256: source.Files[0].SHA256,
|
|
Size: source.Files[0].Size,
|
|
}},
|
|
}
|
|
data, err := json.Marshal(state)
|
|
if err != nil {
|
|
t.Fatalf("Marshal() error = %v", err)
|
|
}
|
|
if !strings.Contains(string(data), `"published_at":"2026-05-30T11:12:00Z"`) {
|
|
t.Fatalf("json = %s, want UTC RFC3339 published_at", data)
|
|
}
|
|
}
|
|
|
|
func validStateJSON(t *testing.T) string {
|
|
t.Helper()
|
|
return validStateWithManifestJSON(t, manifestJSON(t))
|
|
}
|
|
|
|
func validStateWithManifestJSON(t *testing.T, manifest string) string {
|
|
t.Helper()
|
|
return `{
|
|
"schema_version": 1,
|
|
"distributor_version": "dev",
|
|
"pipeline_id": "reports",
|
|
"destination_id": "archive",
|
|
"published_at": "2026-05-30T11:12:00Z",
|
|
"source": {
|
|
"manifest": ` + manifest + `
|
|
},
|
|
"outputs": [
|
|
{
|
|
"path": "report.md",
|
|
"kind": "source",
|
|
"source_path": "report.md",
|
|
"sha256": "sha256:3640fd37140ee4d2e0e93e78834f232ea67a50e7bc6279203690cc7de1975fa6",
|
|
"size": 16
|
|
}
|
|
]
|
|
}`
|
|
}
|
|
|
|
func manifestJSON(t *testing.T) string {
|
|
t.Helper()
|
|
data, err := os.ReadFile("../bundle/testdata/valid_bundle/manifest.json")
|
|
if err != nil {
|
|
t.Fatalf("read manifest fixture: %v", err)
|
|
}
|
|
return string(data)
|
|
}
|
|
|
|
func validManifest(t *testing.T) bundle.Manifest {
|
|
t.Helper()
|
|
manifest, err := bundle.ParseManifest([]byte(manifestJSON(t)))
|
|
if err != nil {
|
|
t.Fatalf("ParseManifest() error = %v", err)
|
|
}
|
|
return manifest
|
|
}
|
|
|
|
func assertStateErrorContains(t *testing.T, err error, want string) {
|
|
t.Helper()
|
|
if err == nil {
|
|
t.Fatalf("error = nil, want substring %q", want)
|
|
}
|
|
if !strings.Contains(err.Error(), want) {
|
|
t.Fatalf("error = %q, want substring %q", err.Error(), want)
|
|
}
|
|
}
|