566 lines
16 KiB
Go
566 lines
16 KiB
Go
package config
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestValidatePublishTransformPolicy(t *testing.T) {
|
|
tests := publishTransformPolicyCases()
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := ValidatePublishTransformPolicy(tt.publish, tt.transform)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("ValidatePublishTransformPolicy() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("ValidatePublishTransformPolicy() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateChecksPublishTransformPolicy(t *testing.T) {
|
|
tests := publishTransformPolicyCases()
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{
|
|
Backend: BackendLocal,
|
|
Path: "/source",
|
|
},
|
|
Destinations: []Destination{{
|
|
ID: "archive",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
Publish: &tt.publish,
|
|
Transform: tt.transform,
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateAcceptsForceReplacementTransferActions(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{
|
|
Backend: BackendLocal,
|
|
Path: "/source",
|
|
},
|
|
Destinations: []Destination{{
|
|
ID: "archive",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
Transfer: TransferPolicy{
|
|
OnDestinationNewer: TransferActionReplace,
|
|
OnConflict: TransferActionReplace,
|
|
},
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
if err := Validate(cfg); err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestValidatePathMapping(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mode string
|
|
wantErr bool
|
|
}{
|
|
{name: "preserve relative", mode: PathMappingPreserveRelative},
|
|
{name: "fixed", mode: PathMappingFixed},
|
|
{name: "invalid", mode: "archive", wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{Backend: BackendLocal, Path: "/source"},
|
|
Destinations: []Destination{{
|
|
ID: "archive",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
PathMap: PathMapping{Mode: tt.mode},
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateReconciliationPolicy(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mode string
|
|
wantErr bool
|
|
}{
|
|
{name: "replace", mode: ReconciliationModeReplace},
|
|
{name: "merge", mode: ReconciliationModeMerge},
|
|
{name: "invalid", mode: "append", wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{Backend: BackendLocal, Path: "/source"},
|
|
Destinations: []Destination{{
|
|
ID: "archive",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
Reconciliation: ReconciliationPolicy{Mode: tt.mode},
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateTakeoverPolicy(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mode string
|
|
wantErr bool
|
|
}{
|
|
{name: "same pipeline", mode: TakeoverModeSamePipeline},
|
|
{name: "same source", mode: TakeoverModeSameSource},
|
|
{name: "any managed", mode: TakeoverModeAnyManaged},
|
|
{name: "never", mode: TakeoverModeNever},
|
|
{name: "invalid", mode: "unmanaged", wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{Backend: BackendLocal, Path: "/source"},
|
|
Destinations: []Destination{{
|
|
ID: "archive",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
Takeover: TakeoverPolicy{Mode: tt.mode},
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateTakeoverPolicyReportsFieldContext(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{Backend: BackendLocal, Path: "/source"},
|
|
Destinations: []Destination{{
|
|
ID: "archive",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
Takeover: TakeoverPolicy{Mode: "unmanaged"},
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
want := "pipelines[0].destinations[0].takeover.mode must be same_pipeline, same_source, any_managed, or never"
|
|
if !strings.Contains(err.Error(), want) {
|
|
t.Fatalf("Validate() error = %q, want %q", err, want)
|
|
}
|
|
}
|
|
|
|
func TestValidateStatePolicy(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mode string
|
|
wantErr bool
|
|
}{
|
|
{name: "single owner", mode: StateModeSingleOwner},
|
|
{name: "shared root", mode: StateModeSharedRoot},
|
|
{name: "invalid", mode: "shared", wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{Backend: BackendLocal, Path: "/source"},
|
|
Destinations: []Destination{{
|
|
ID: "archive",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
State: StatePolicy{Mode: tt.mode},
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateRetentionPolicy(t *testing.T) {
|
|
olderThan := Duration(24 * time.Hour)
|
|
zeroDuration := Duration(0)
|
|
keepZero := 0
|
|
keepThree := 3
|
|
keepNegative := -1
|
|
tests := []struct {
|
|
name string
|
|
retention RetentionPolicy
|
|
wantErr bool
|
|
}{
|
|
{name: "disabled"},
|
|
{name: "older than", retention: RetentionPolicy{Prune: PrunePolicy{Enabled: true, OlderThan: &olderThan}}},
|
|
{name: "keep zero", retention: RetentionPolicy{Prune: PrunePolicy{Enabled: true, KeepLatest: &keepZero}}},
|
|
{name: "keep latest", retention: RetentionPolicy{Prune: PrunePolicy{Enabled: true, KeepLatest: &keepThree}}},
|
|
{name: "combined", retention: RetentionPolicy{Prune: PrunePolicy{Enabled: true, OlderThan: &olderThan, KeepLatest: &keepThree}}},
|
|
{name: "missing policy", retention: RetentionPolicy{Prune: PrunePolicy{Enabled: true}}, wantErr: true},
|
|
{name: "zero older than", retention: RetentionPolicy{Prune: PrunePolicy{Enabled: true, OlderThan: &zeroDuration}}, wantErr: true},
|
|
{name: "negative keep latest", retention: RetentionPolicy{Prune: PrunePolicy{Enabled: true, KeepLatest: &keepNegative}}, wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{Backend: BackendLocal, Path: "/source"},
|
|
Destinations: []Destination{{
|
|
ID: "archive",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
Retention: tt.retention,
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateLinks(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
links *Links
|
|
wantErr bool
|
|
}{
|
|
{name: "absent links"},
|
|
{name: "http", links: &Links{BaseURL: "http://reports.example.com/archive", Primary: LinkPrimaryAuto}},
|
|
{name: "https", links: &Links{BaseURL: "https://reports.example.com/archive/", Primary: LinkPrimaryHTML}},
|
|
{name: "source primary", links: &Links{BaseURL: "https://reports.example.com", Primary: LinkPrimarySource}},
|
|
{name: "missing base", links: &Links{Primary: LinkPrimaryAuto}, wantErr: true},
|
|
{name: "ftp scheme", links: &Links{BaseURL: "ftp://reports.example.com", Primary: LinkPrimaryAuto}, wantErr: true},
|
|
{name: "missing host", links: &Links{BaseURL: "https:///archive", Primary: LinkPrimaryAuto}, wantErr: true},
|
|
{name: "query", links: &Links{BaseURL: "https://reports.example.com/archive?preview=1", Primary: LinkPrimaryAuto}, wantErr: true},
|
|
{name: "fragment", links: &Links{BaseURL: "https://reports.example.com/archive#top", Primary: LinkPrimaryAuto}, wantErr: true},
|
|
{name: "invalid primary", links: &Links{BaseURL: "https://reports.example.com", Primary: "document"}, wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{Backend: BackendLocal, Path: "/source"},
|
|
Destinations: []Destination{{
|
|
ID: "web",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
Links: tt.links,
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateLinksReportsFieldContext(t *testing.T) {
|
|
cfg := Config{Pipelines: []Pipeline{{
|
|
ID: "reports",
|
|
Source: Backend{Backend: BackendLocal, Path: "/source"},
|
|
Destinations: []Destination{{
|
|
ID: "web",
|
|
Backend: BackendLocal,
|
|
Path: "/destination",
|
|
Links: &Links{BaseURL: "https://reports.example.com/archive?preview=1", Primary: LinkPrimaryAuto},
|
|
}},
|
|
}}}
|
|
ApplyDefaults(&cfg)
|
|
err := Validate(cfg)
|
|
if err == nil {
|
|
t.Fatal("Validate() error = nil, want error")
|
|
}
|
|
want := "pipelines[0].destinations[0].links.base_url must not include a query string"
|
|
if !strings.Contains(err.Error(), want) {
|
|
t.Fatalf("Validate() error = %q, want %q", err, want)
|
|
}
|
|
}
|
|
|
|
type publishTransformPolicyCase struct {
|
|
name string
|
|
publish PublishPolicy
|
|
transform Transform
|
|
wantErr bool
|
|
}
|
|
|
|
func publishTransformPolicyCases() []publishTransformPolicyCase {
|
|
return []publishTransformPolicyCase{
|
|
{
|
|
name: "source only allowed",
|
|
publish: PublishPolicy{Source: true},
|
|
},
|
|
{
|
|
name: "html only sidecar allowed",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: TransformModeSidecar,
|
|
}},
|
|
},
|
|
{
|
|
name: "html only default mode allowed",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
}},
|
|
},
|
|
{
|
|
name: "html only index allowed",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: TransformModeIndex,
|
|
}},
|
|
},
|
|
{
|
|
name: "html only index input allowed",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: TransformModeIndex,
|
|
Input: "report.md",
|
|
}},
|
|
},
|
|
{
|
|
name: "html only sidecar css href allowed",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: TransformModeSidecar,
|
|
CssHref: "/assets/report.css",
|
|
}},
|
|
},
|
|
{
|
|
name: "html only index css href allowed",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: TransformModeIndex,
|
|
CssHref: "assets/report.css?v=20260614",
|
|
}},
|
|
},
|
|
{
|
|
name: "source and html sidecar allowed",
|
|
publish: PublishPolicy{Source: true, HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: TransformModeSidecar,
|
|
}},
|
|
},
|
|
{
|
|
name: "no outputs rejected",
|
|
publish: PublishPolicy{},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "html without transform rejected",
|
|
publish: PublishPolicy{HTML: true},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "html with disabled transform rejected",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: false,
|
|
Mode: TransformModeSidecar,
|
|
}},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "html with wrong mode rejected",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: "inline",
|
|
}},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "source only enabled transform rejected",
|
|
publish: PublishPolicy{Source: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: TransformModeSidecar,
|
|
}},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "enabled markdown wrong mode rejected",
|
|
publish: PublishPolicy{Source: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: "inline",
|
|
}},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "sidecar input rejected",
|
|
publish: PublishPolicy{HTML: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: true,
|
|
Mode: TransformModeSidecar,
|
|
Input: "report.md",
|
|
}},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "disabled markdown empty mode allowed",
|
|
publish: PublishPolicy{Source: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: false,
|
|
}},
|
|
},
|
|
{
|
|
name: "disabled markdown sidecar mode allowed",
|
|
publish: PublishPolicy{Source: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: false,
|
|
Mode: TransformModeSidecar,
|
|
}},
|
|
},
|
|
{
|
|
name: "disabled markdown index mode allowed",
|
|
publish: PublishPolicy{Source: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: false,
|
|
Mode: TransformModeIndex,
|
|
}},
|
|
},
|
|
{
|
|
name: "disabled markdown input rejected",
|
|
publish: PublishPolicy{Source: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: false,
|
|
Mode: TransformModeIndex,
|
|
Input: "report.md",
|
|
}},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "disabled markdown css href rejected",
|
|
publish: PublishPolicy{Source: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: false,
|
|
Mode: TransformModeSidecar,
|
|
CssHref: "/assets/report.css",
|
|
}},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "disabled markdown wrong mode rejected",
|
|
publish: PublishPolicy{Source: true},
|
|
transform: Transform{MarkdownToHTML: &MarkdownToHTML{
|
|
Enabled: false,
|
|
Mode: "inline",
|
|
}},
|
|
wantErr: true,
|
|
},
|
|
}
|
|
}
|
|
|
|
func TestValidateCSSHref(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
value string
|
|
wantErr bool
|
|
}{
|
|
{name: "empty"},
|
|
{name: "root relative", value: "/assets/report.css"},
|
|
{name: "relative", value: "assets/report.css"},
|
|
{name: "parent relative", value: "../assets/report.css"},
|
|
{name: "query", value: "/assets/report.css?v=20260614"},
|
|
{name: "http", value: "http://example.com/report.css"},
|
|
{name: "https", value: "https://example.com/assets/report.css?v=1"},
|
|
{name: "javascript", value: "javascript:alert(1)", wantErr: true},
|
|
{name: "data", value: "data:text/css,body{}", wantErr: true},
|
|
{name: "file", value: "file:///tmp/report.css", wantErr: true},
|
|
{name: "scheme relative", value: "//example.com/report.css", wantErr: true},
|
|
{name: "userinfo", value: "https://user@example.com/report.css", wantErr: true},
|
|
{name: "fragment", value: "/assets/report.css#main", wantErr: true},
|
|
{name: "space", value: "/assets/report css", wantErr: true},
|
|
{name: "tab", value: "/assets/report\tcss", wantErr: true},
|
|
{name: "newline", value: "/assets/report\ncss", wantErr: true},
|
|
{name: "backslash", value: `assets\report.css`, wantErr: true},
|
|
{name: "less than", value: "/assets/<report>.css", wantErr: true},
|
|
{name: "double quote", value: `/assets/"report".css`, wantErr: true},
|
|
{name: "single quote", value: "/assets/'report'.css", wantErr: true},
|
|
{name: "query only", value: "?v=1", wantErr: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := validateCSSHref(tt.value)
|
|
if tt.wantErr && err == nil {
|
|
t.Fatal("validateCSSHref() error = nil, want error")
|
|
}
|
|
if !tt.wantErr && err != nil {
|
|
t.Fatalf("validateCSSHref() error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|