Something went wrong. Try again.
sloproxy
Something went wrong. Try again.
8.4 kB · 234 lines
Go
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235package config
import ( "bytes" "encoding/json" "errors" "io" "math" "os" "path/filepath" "reflect" "testing" "time")
func TestLoadConfigOptionalMissingFallbackAppliesCredentialInFlightDefaults(t *testing.T) { cfg, errLoad := LoadConfigOptional(filepath.Join(t.TempDir(), "missing.yaml"), true) if errLoad != nil { t.Fatalf("LoadConfigOptional() error = %v", errLoad) } assertOptionalConfigFallback(t, cfg)}
func TestLoadConfigOptionalEmptyFallbackAppliesCredentialInFlightDefaults(t *testing.T) { configPath := filepath.Join(t.TempDir(), "config.yaml") if errWrite := os.WriteFile(configPath, nil, 0o600); errWrite != nil { t.Fatal(errWrite) } cfg, errLoad := LoadConfigOptional(configPath, true) if errLoad != nil { t.Fatalf("LoadConfigOptional() error = %v", errLoad) } assertOptionalConfigFallback(t, cfg)}
func TestLoadConfigOptionalWhitespaceFallbackAppliesCredentialInFlightDefaults(t *testing.T) { configPath := filepath.Join(t.TempDir(), "config.yaml") if errWrite := os.WriteFile(configPath, []byte(" \t\n\r "), 0o600); errWrite != nil { t.Fatal(errWrite) } cfg, errLoad := LoadConfigOptional(configPath, true) if errLoad != nil { t.Fatalf("LoadConfigOptional() error = %v", errLoad) } assertOptionalConfigFallback(t, cfg)}
func TestLoadConfigOptionalInvalidFallbackAppliesCredentialInFlightDefaults(t *testing.T) { configPath := filepath.Join(t.TempDir(), "config.yaml") if errWrite := os.WriteFile(configPath, []byte(":"), 0o600); errWrite != nil { t.Fatal(errWrite) } cfg, errLoad := LoadConfigOptional(configPath, true) if errLoad != nil { t.Fatalf("LoadConfigOptional() error = %v", errLoad) } assertOptionalConfigFallback(t, cfg)}
func assertOptionalConfigFallback(t *testing.T, cfg *Config) { t.Helper() if cfg.CredentialInFlight != DefaultCredentialInFlightConfig() { t.Fatalf("CredentialInFlight = %#v, want %#v", cfg.CredentialInFlight, DefaultCredentialInFlightConfig()) } if errValidate := cfg.CredentialInFlight.Validate(); errValidate != nil { t.Fatalf("CredentialInFlight.Validate() error = %v", errValidate) } if cfg.ErrorLogsMaxFiles != 0 || cfg.WebsocketAuth || cfg.CredentialConcurrency != (CredentialConcurrencyConfig{}) { t.Fatalf("fallback config changed existing empty-config defaults: %#v", cfg) }}
func TestCredentialInFlightConfigContractFixture(t *testing.T) { raw, errRead := os.ReadFile(filepath.Join("..", "home", "testdata", "credential_in_flight_contract.json")) if errRead != nil { t.Fatal(errRead) } fixture, errDecode := decodeCredentialInFlightConfigFixture(raw) if errDecode != nil { t.Fatal(errDecode) } if fixture.Config != DefaultCredentialInFlightConfig() { t.Fatalf("default config = %#v, want %#v", DefaultCredentialInFlightConfig(), fixture.Config) } if errValidate := fixture.Config.Validate(); errValidate != nil { t.Fatalf("Validate() error = %v", errValidate) } assertCredentialInFlightConfigFields(t) assertRequiredJSONKeys(t, raw, []string{"config", "part", "overflow"}) assertRequiredJSONKeys(t, fixture.ConfigJSON, []string{"snapshot-interval", "stale-after", "max-part-bytes", "max-part-count", "max-revision-bytes", "max-aggregate-groups", "max-details", "max-string-bytes", "staging-retention"})}
func TestCredentialInFlightConfigFixtureRejectsInvalidJSON(t *testing.T) { raw, errRead := os.ReadFile(filepath.Join("..", "home", "testdata", "credential_in_flight_contract.json")) if errRead != nil { t.Fatal(errRead) } for _, test := range []struct { name string raw []byte }{ {name: "unknown config field", raw: bytes.Replace(raw, []byte(`"snapshot-interval": "2s"`), []byte(`"snapshot-interval": "2s", "secret": "secret"`), 1)}, {name: "trailing JSON", raw: append(append([]byte{}, raw...), []byte(` {"config": {}}`)...)}, } { t.Run(test.name, func(t *testing.T) { if _, errDecode := decodeCredentialInFlightConfigFixture(test.raw); errDecode == nil { t.Fatal("decodeCredentialInFlightConfigFixture() error = nil") } }) }}
func TestCredentialInFlightConfigDurationBounds(t *testing.T) { for _, test := range []struct { name string stale string every string valid bool }{ {name: "exact three intervals", every: "1s", stale: "3s", valid: true}, {name: "below three intervals", every: "1s", stale: "2999999999ns", valid: false}, {name: "near duration maximum", every: time.Duration(math.MaxInt64 / 2).String(), stale: time.Duration(math.MaxInt64).String(), valid: false}, } { t.Run(test.name, func(t *testing.T) { cfg := DefaultCredentialInFlightConfig() cfg.SnapshotInterval = test.every cfg.StaleAfter = test.stale errValidate := cfg.Validate() if (errValidate == nil) != test.valid { t.Fatalf("Validate() error = %v, want valid = %t", errValidate, test.valid) } }) }}
func TestCredentialInFlightConfigRejectsUnsafeBounds(t *testing.T) { cfg := DefaultCredentialInFlightConfig() cfg.StaleAfter = "5s" if errValidate := cfg.Validate(); errValidate == nil { t.Fatal("Validate() error = nil, want stale-after error") } cfg = DefaultCredentialInFlightConfig() cfg.MaxRevisionBytes = 16*1024*1024 + 1 if errValidate := cfg.Validate(); errValidate == nil { t.Fatal("Validate() error = nil, want hard revision bound error") } cfg = DefaultCredentialInFlightConfig() cfg.MaxPartBytes = math.MaxInt if errValidate := cfg.Validate(); errValidate == nil { t.Fatal("Validate() error = nil, want overflow-safe part bound error") }}
type credentialInFlightConfigFixture struct { Config CredentialInFlightConfig `json:"config"` ConfigJSON json.RawMessage `json:"-"`}
func decodeCredentialInFlightConfigFixture(raw []byte) (credentialInFlightConfigFixture, error) { var fixture credentialInFlightConfigFixture var document struct { Config json.RawMessage `json:"config"` Part json.RawMessage `json:"part"` Overflow json.RawMessage `json:"overflow"` } decoder := json.NewDecoder(bytes.NewReader(raw)) decoder.DisallowUnknownFields() if errDecode := decoder.Decode(&document); errDecode != nil { return fixture, errDecode } if errDecode := decoder.Decode(&struct{}{}); errDecode == nil { return fixture, errors.New("unexpected trailing JSON") } else if errDecode != io.EOF { return fixture, errDecode } decoder = json.NewDecoder(bytes.NewReader(document.Config)) decoder.DisallowUnknownFields() if errDecode := decoder.Decode(&fixture.Config); errDecode != nil { return fixture, errDecode } if errDecode := decoder.Decode(&struct{}{}); errDecode == nil { return fixture, errors.New("unexpected trailing config JSON") } else if errDecode != io.EOF { return fixture, errDecode } fixture.ConfigJSON = document.Config return fixture, nil}
func assertCredentialInFlightConfigFields(t *testing.T) { t.Helper() assertOrderedJSONFields(t, reflect.TypeOf(CredentialInFlightConfig{}), []jsonField{ {name: "SnapshotInterval", tag: "snapshot-interval"}, {name: "StaleAfter", tag: "stale-after"}, {name: "MaxPartBytes", tag: "max-part-bytes"}, {name: "MaxPartCount", tag: "max-part-count"}, {name: "MaxRevisionBytes", tag: "max-revision-bytes"}, {name: "MaxAggregateGroups", tag: "max-aggregate-groups"}, {name: "MaxDetails", tag: "max-details"}, {name: "MaxStringBytes", tag: "max-string-bytes"}, {name: "StagingRetention", tag: "staging-retention"}, })}
type jsonField struct { name string tag string}
func assertOrderedJSONFields(t *testing.T, structType reflect.Type, want []jsonField) { t.Helper() if structType.NumField() != len(want) { t.Fatalf("%s field count = %d, want %d", structType.Name(), structType.NumField(), len(want)) } for index, expected := range want { field := structType.Field(index) if field.Name != expected.name || field.Tag.Get("json") != expected.tag { t.Fatalf("%s field %d = (%q, %q), want (%q, %q)", structType.Name(), index, field.Name, field.Tag.Get("json"), expected.name, expected.tag) } }}
func assertRequiredJSONKeys(t *testing.T, raw json.RawMessage, required []string) { t.Helper() var fields map[string]json.RawMessage if errDecode := json.Unmarshal(raw, &fields); errDecode != nil { t.Fatalf("json.Unmarshal() error = %v", errDecode) } for _, key := range required { if _, ok := fields[key]; !ok { t.Fatalf("required JSON key %q is missing", key) } }}