1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
20 "git.arvados.org/arvados.git/sdk/go/arvados"
21 "git.arvados.org/arvados.git/sdk/go/ctxlog"
22 "github.com/ghodss/yaml"
23 "github.com/prometheus/client_golang/prometheus"
24 "github.com/prometheus/common/expfmt"
25 "github.com/sirupsen/logrus"
26 "golang.org/x/sys/unix"
27 check "gopkg.in/check.v1"
30 // Gocheck boilerplate
31 func Test(t *testing.T) {
35 var _ = check.Suite(&LoadSuite{})
37 var emptyConfigYAML = `Clusters: {"z1111": {}}`
39 // Return a new Loader that reads cluster config from configdata
40 // (instead of the usual default /etc/arvados/config.yml), and logs to
41 // logdst or (if that's nil) c.Log.
42 func testLoader(c *check.C, configdata string, logdst io.Writer) *Loader {
43 logger := ctxlog.TestLogger(c)
49 ldr := NewLoader(bytes.NewBufferString(configdata), logger)
54 type LoadSuite struct{}
56 func (s *LoadSuite) SetUpSuite(c *check.C) {
57 os.Unsetenv("ARVADOS_API_HOST")
58 os.Unsetenv("ARVADOS_API_HOST_INSECURE")
59 os.Unsetenv("ARVADOS_API_TOKEN")
62 func (s *LoadSuite) TestEmpty(c *check.C) {
63 cfg, err := testLoader(c, "", nil).Load()
64 c.Check(cfg, check.IsNil)
65 c.Assert(err, check.ErrorMatches, `config does not define any clusters`)
68 func (s *LoadSuite) TestNoConfigs(c *check.C) {
69 cfg, err := testLoader(c, emptyConfigYAML, nil).Load()
70 c.Assert(err, check.IsNil)
71 c.Assert(cfg.Clusters, check.HasLen, 1)
72 cc, err := cfg.GetCluster("z1111")
73 c.Assert(err, check.IsNil)
74 c.Check(cc.ClusterID, check.Equals, "z1111")
75 c.Check(cc.API.MaxRequestAmplification, check.Equals, 4)
76 c.Check(cc.API.MaxItemsPerResponse, check.Equals, 1000)
79 func (s *LoadSuite) TestNullKeyDoesNotOverrideDefault(c *check.C) {
80 ldr := testLoader(c, `{"Clusters":{"z1111":{"API":}}}`, nil)
81 ldr.SkipDeprecated = true
82 cfg, err := ldr.Load()
83 c.Assert(err, check.IsNil)
84 c1, err := cfg.GetCluster("z1111")
85 c.Assert(err, check.IsNil)
86 c.Check(c1.ClusterID, check.Equals, "z1111")
87 c.Check(c1.API.MaxRequestAmplification, check.Equals, 4)
88 c.Check(c1.API.MaxItemsPerResponse, check.Equals, 1000)
91 func (s *LoadSuite) TestMungeLegacyConfigArgs(c *check.C) {
92 f, err := ioutil.TempFile("", "")
93 c.Check(err, check.IsNil)
94 defer os.Remove(f.Name())
95 io.WriteString(f, "Debug: true\n")
98 f, err = ioutil.TempFile("", "")
99 c.Check(err, check.IsNil)
100 defer os.Remove(f.Name())
101 io.WriteString(f, emptyConfigYAML)
104 for _, trial := range []struct {
109 []string{"-config", oldfile},
110 []string{"-old-config", oldfile},
113 []string{"-config=" + oldfile},
114 []string{"-old-config=" + oldfile},
117 []string{"-config", newfile},
118 []string{"-config", newfile},
121 []string{"-config=" + newfile},
122 []string{"-config=" + newfile},
125 []string{"-foo", oldfile},
126 []string{"-foo", oldfile},
129 []string{"-foo=" + oldfile},
130 []string{"-foo=" + oldfile},
133 []string{"-foo", "-config=" + oldfile},
134 []string{"-foo", "-old-config=" + oldfile},
137 []string{"-foo", "bar", "-config=" + oldfile},
138 []string{"-foo", "bar", "-old-config=" + oldfile},
141 []string{"-foo=bar", "baz", "-config=" + oldfile},
142 []string{"-foo=bar", "baz", "-old-config=" + oldfile},
145 []string{"-config=/dev/null"},
146 []string{"-config=/dev/null"},
149 []string{"-config=-"},
150 []string{"-config=-"},
153 []string{"-config="},
154 []string{"-config="},
157 []string{"-foo=bar", "baz", "-config"},
158 []string{"-foo=bar", "baz", "-config"},
165 var logbuf bytes.Buffer
166 logger := logrus.New()
170 args := ldr.MungeLegacyConfigArgs(logger, trial.argsIn, "-old-config")
171 c.Check(args, check.DeepEquals, trial.argsOut)
172 if fmt.Sprintf("%v", trial.argsIn) != fmt.Sprintf("%v", trial.argsOut) {
173 c.Check(logbuf.String(), check.Matches, `.*`+oldfile+` is not a cluster config file -- interpreting -config as -old-config.*\n`)
178 func (s *LoadSuite) TestSampleKeys(c *check.C) {
179 for _, yaml := range []string{
180 `{"Clusters":{"z1111":{}}}`,
181 `{"Clusters":{"z1111":{"InstanceTypes":{"Foo":{"RAM": "12345M"}}}}}`,
183 cfg, err := testLoader(c, yaml, nil).Load()
184 c.Assert(err, check.IsNil)
185 cc, err := cfg.GetCluster("z1111")
186 c.Assert(err, check.IsNil)
187 _, hasSample := cc.InstanceTypes["SAMPLE"]
188 c.Check(hasSample, check.Equals, false)
189 if strings.Contains(yaml, "Foo") {
190 c.Check(cc.InstanceTypes["Foo"].RAM, check.Equals, arvados.ByteSize(12345000000))
191 c.Check(cc.InstanceTypes["Foo"].Price, check.Equals, 0.0)
196 func (s *LoadSuite) TestMultipleClusters(c *check.C) {
197 ldr := testLoader(c, `{"Clusters":{"z1111":{},"z2222":{}}}`, nil)
198 ldr.SkipDeprecated = true
199 cfg, err := ldr.Load()
200 c.Assert(err, check.IsNil)
201 c1, err := cfg.GetCluster("z1111")
202 c.Assert(err, check.IsNil)
203 c.Check(c1.ClusterID, check.Equals, "z1111")
204 c2, err := cfg.GetCluster("z2222")
205 c.Assert(err, check.IsNil)
206 c.Check(c2.ClusterID, check.Equals, "z2222")
209 func (s *LoadSuite) TestDeprecatedOrUnknownWarning(c *check.C) {
210 var logbuf bytes.Buffer
211 _, err := testLoader(c, `
214 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
215 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
217 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
224 Host: z2222.arvadosapi.com
230 "http://host.example:12345": {}
233 "http://host.example:12345":
238 "http://host.example:12345": {}
240 zzzzz-nyw5e-aaaaaaaaaaaaaaa: {}
242 c.Assert(err, check.IsNil)
243 c.Log(logbuf.String())
244 logs := strings.Split(strings.TrimSuffix(logbuf.String(), "\n"), "\n")
245 for _, log := range logs {
246 c.Check(log, check.Matches, `.*deprecated or unknown config entry:.*(RunTimeEngine.*RuntimeEngine|BadKey1|BadKey2|KeepStore|ServiceS|RendezVous).*`)
248 c.Check(logs, check.HasLen, 6)
251 func (s *LoadSuite) checkSAMPLEKeys(c *check.C, path string, x interface{}) {
252 v := reflect.Indirect(reflect.ValueOf(x))
255 var stringKeys, sampleKey bool
259 if k.Kind() == reflect.String {
261 if k.String() == "SAMPLE" || k.String() == "xxxxx" {
263 s.checkSAMPLEKeys(c, path+"."+k.String(), iter.Value().Interface())
267 if stringKeys && !sampleKey {
268 c.Errorf("%s is a map with string keys (type %T) but config.default.yml has no SAMPLE key", path, x)
272 for i := 0; i < v.NumField(); i++ {
274 if val.CanInterface() {
275 s.checkSAMPLEKeys(c, path+"."+v.Type().Field(i).Name, val.Interface())
281 func (s *LoadSuite) TestDefaultConfigHasAllSAMPLEKeys(c *check.C) {
282 var logbuf bytes.Buffer
283 loader := testLoader(c, string(DefaultYAML), &logbuf)
284 cfg, err := loader.Load()
285 c.Assert(err, check.IsNil)
286 s.checkSAMPLEKeys(c, "", cfg)
289 func (s *LoadSuite) TestNoUnrecognizedKeysInDefaultConfig(c *check.C) {
290 var logbuf bytes.Buffer
291 var supplied map[string]interface{}
292 yaml.Unmarshal(DefaultYAML, &supplied)
294 loader := testLoader(c, string(DefaultYAML), &logbuf)
295 cfg, err := loader.Load()
296 c.Assert(err, check.IsNil)
297 var loaded map[string]interface{}
298 buf, err := yaml.Marshal(cfg)
299 c.Assert(err, check.IsNil)
300 err = yaml.Unmarshal(buf, &loaded)
301 c.Assert(err, check.IsNil)
303 c.Check(logbuf.String(), check.Matches, `(?ms).*SystemRootToken: secret token is not set.*`)
304 c.Check(logbuf.String(), check.Matches, `(?ms).*ManagementToken: secret token is not set.*`)
305 c.Check(logbuf.String(), check.Matches, `(?ms).*Collections.BlobSigningKey: secret token is not set.*`)
307 loader.logExtraKeys(loaded, supplied, "")
308 c.Check(logbuf.String(), check.Equals, "")
311 func (s *LoadSuite) TestNoWarningsForDumpedConfig(c *check.C) {
312 var logbuf bytes.Buffer
313 cfg, err := testLoader(c, `
316 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
317 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
319 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`, &logbuf).Load()
320 c.Assert(err, check.IsNil)
321 yaml, err := yaml.Marshal(cfg)
322 c.Assert(err, check.IsNil)
323 // Well, *nearly* no warnings. SourceTimestamp and
324 // SourceSHA256 are included in a config-dump, but not
325 // expected in a real config file.
326 yaml = regexp.MustCompile(`(^|\n)(Source(Timestamp|SHA256): .*?\n)+`).ReplaceAll(yaml, []byte("$1"))
327 cfgDumped, err := testLoader(c, string(yaml), &logbuf).Load()
328 c.Assert(err, check.IsNil)
329 // SourceTimestamp and SourceSHA256 aren't expected to be
330 // preserved through dump+load
331 cfgDumped.SourceTimestamp = cfg.SourceTimestamp
332 cfgDumped.SourceSHA256 = cfg.SourceSHA256
333 c.Check(cfg, check.DeepEquals, cfgDumped)
334 c.Check(logbuf.String(), check.Equals, "")
337 func (s *LoadSuite) TestUnacceptableTokens(c *check.C) {
338 for _, trial := range []struct {
343 {false, "SystemRootToken", "SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_b_c"},
344 {false, "ManagementToken", "ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa b c"},
345 {false, "ManagementToken", "ManagementToken: \"$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabc\""},
346 {false, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa⛵\"}"},
347 {true, "SystemRootToken", "SystemRootToken: a_b_c"},
348 {true, "ManagementToken", "ManagementToken: a b c"},
349 {true, "ManagementToken", "ManagementToken: \"$abc\""},
350 {true, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"⛵\"}"},
352 c.Logf("trying bogus config: %s", trial.example)
353 _, err := testLoader(c, "Clusters:\n zzzzz:\n "+trial.example, nil).Load()
354 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.`+trial.configPath+`: unacceptable characters in token.*`)
358 func (s *LoadSuite) TestPostgreSQLKeyConflict(c *check.C) {
359 _, err := testLoader(c, `
367 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.PostgreSQL.Connection: multiple entries for "(dbname|host)".*`)
370 func (s *LoadSuite) TestBadClusterIDs(c *check.C) {
371 for _, data := range []string{`
374 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
375 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
377 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
381 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
382 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
384 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
387 Host: Zzzzz.arvadosapi.com
392 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
393 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
395 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
401 v, err := testLoader(c, data, nil).Load()
403 c.Logf("%#v", v.Clusters)
405 c.Check(err, check.ErrorMatches, `.*cluster ID should be 5 alphanumeric characters.*`)
409 func (s *LoadSuite) TestBadType(c *check.C) {
410 for _, data := range []string{`
423 ConnectionPool: "foo"
433 ConnectionPool: [] # {foo: bar} isn't caught here; we rely on config-check
437 v, err := testLoader(c, data, nil).Load()
439 c.Logf("%#v", v.Clusters["zzzzz"].PostgreSQL.ConnectionPool)
441 c.Check(err, check.ErrorMatches, `.*cannot unmarshal .*PostgreSQL.*`)
445 func (s *LoadSuite) TestMovedKeys(c *check.C) {
446 checkEquivalent(c, `# config has old keys only
450 MultiClusterRequestConcurrency: 3
451 MaxItemsPerResponse: 999
456 MaxRequestAmplification: 3
457 MaxItemsPerResponse: 999
459 checkEquivalent(c, `# config has both old and new keys; old values win
463 MultiClusterRequestConcurrency: 0
464 MaxItemsPerResponse: 555
466 MaxRequestAmplification: 3
467 MaxItemsPerResponse: 999
472 MaxRequestAmplification: 0
473 MaxItemsPerResponse: 555
477 func checkEquivalent(c *check.C, goty, expectedy string) string {
478 var logbuf bytes.Buffer
479 gotldr := testLoader(c, goty, &logbuf)
480 expectedldr := testLoader(c, expectedy, nil)
481 checkEquivalentLoaders(c, gotldr, expectedldr)
482 return logbuf.String()
485 func checkEqualYAML(c *check.C, got, expected interface{}) {
486 expectedyaml, err := yaml.Marshal(expected)
487 c.Assert(err, check.IsNil)
488 gotyaml, err := yaml.Marshal(got)
489 c.Assert(err, check.IsNil)
490 if !bytes.Equal(gotyaml, expectedyaml) {
491 cmd := exec.Command("diff", "-u", "--label", "expected", "--label", "got", "/dev/fd/3", "/dev/fd/4")
492 for _, y := range [][]byte{expectedyaml, gotyaml} {
493 pr, pw, err := os.Pipe()
494 c.Assert(err, check.IsNil)
496 go func(data []byte) {
500 cmd.ExtraFiles = append(cmd.ExtraFiles, pr)
502 diff, err := cmd.CombinedOutput()
503 // diff should report differences and exit non-zero.
504 c.Check(err, check.NotNil)
506 c.Error("got != expected; see diff (-expected +got) above")
510 func checkEquivalentLoaders(c *check.C, gotldr, expectedldr *Loader) {
511 got, err := gotldr.Load()
512 c.Assert(err, check.IsNil)
513 expected, err := expectedldr.Load()
514 c.Assert(err, check.IsNil)
515 // The inputs generally aren't even files, so SourceTimestamp
516 // can't be expected to match.
517 got.SourceTimestamp = expected.SourceTimestamp
518 // Obviously the content isn't identical -- otherwise we
519 // wouldn't need to check that it's equivalent.
520 got.SourceSHA256 = expected.SourceSHA256
521 checkEqualYAML(c, got, expected)
524 func checkListKeys(path string, x interface{}) (err error) {
525 v := reflect.Indirect(reflect.ValueOf(x))
531 if k.Kind() == reflect.String {
532 if err = checkListKeys(path+"."+k.String(), iter.Value().Interface()); err != nil {
540 for i := 0; i < v.NumField(); i++ {
542 structField := v.Type().Field(i)
543 fieldname := structField.Name
544 endsWithList := strings.HasSuffix(fieldname, "List")
545 isAnArray := structField.Type.Kind() == reflect.Slice
546 if endsWithList != isAnArray {
548 err = fmt.Errorf("%s.%s ends with 'List' but field is not an array (type %v)", path, fieldname, val.Kind())
551 if isAnArray && structField.Type.Elem().Kind() != reflect.Uint8 {
552 err = fmt.Errorf("%s.%s is an array but field name does not end in 'List' (slice of %v)", path, fieldname, structField.Type.Elem().Kind())
556 if val.CanInterface() {
557 checkListKeys(path+"."+fieldname, val.Interface())
564 func (s *LoadSuite) TestListKeys(c *check.C) {
567 }{[]string{"a", "b"}}
568 var m1 = make(map[string]interface{})
570 if err := checkListKeys("", m1); err != nil {
576 }{[]string{"a", "b"}}
577 var m2 = make(map[string]interface{})
579 if err := checkListKeys("", m2); err == nil {
580 c.Errorf("Should have produced an error")
586 var m3 = make(map[string]interface{})
588 if err := checkListKeys("", m3); err == nil {
589 c.Errorf("Should have produced an error")
592 loader := testLoader(c, string(DefaultYAML), nil)
593 cfg, err := loader.Load()
594 c.Assert(err, check.IsNil)
595 if err := checkListKeys("", cfg); err != nil {
600 func (s *LoadSuite) TestImplicitStorageClasses(c *check.C) {
601 // If StorageClasses and Volumes.*.StorageClasses are all
602 // empty, there is a default storage class named "default".
603 ldr := testLoader(c, `{"Clusters":{"z1111":{}}}`, nil)
604 cfg, err := ldr.Load()
605 c.Assert(err, check.IsNil)
606 cc, err := cfg.GetCluster("z1111")
607 c.Assert(err, check.IsNil)
608 c.Check(cc.StorageClasses, check.HasLen, 1)
609 c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
610 c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
612 // The implicit "default" storage class is used by all
614 ldr = testLoader(c, `
619 cfg, err = ldr.Load()
620 c.Assert(err, check.IsNil)
621 cc, err = cfg.GetCluster("z1111")
622 c.Assert(err, check.IsNil)
623 c.Check(cc.StorageClasses, check.HasLen, 1)
624 c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
625 c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
626 c.Check(cc.Volumes["z"].StorageClasses["default"], check.Equals, true)
628 // The "default" storage class isn't implicit if any classes
629 // are configured explicitly.
630 ldr = testLoader(c, `
641 cfg, err = ldr.Load()
642 c.Assert(err, check.IsNil)
643 cc, err = cfg.GetCluster("z1111")
644 c.Assert(err, check.IsNil)
645 c.Check(cc.StorageClasses, check.HasLen, 1)
646 c.Check(cc.StorageClasses["local"].Default, check.Equals, true)
647 c.Check(cc.StorageClasses["local"].Priority, check.Equals, 111)
649 // It is an error for a volume to refer to a storage class
650 // that isn't listed in StorageClasses.
651 ldr = testLoader(c, `
663 c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "nx" that is not defined.*`)
665 // It is an error for a volume to refer to a storage class
666 // that isn't listed in StorageClasses ... even if it's
667 // "default", which would exist implicitly if it weren't
668 // referenced explicitly by a volume.
669 ldr = testLoader(c, `
677 c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "default" that is not defined.*`)
679 // If the "default" storage class is configured explicitly, it
680 // is not used implicitly by any volumes, even if it's the
681 // only storage class.
682 var logbuf bytes.Buffer
683 ldr = testLoader(c, `
693 c.Assert(err, check.ErrorMatches, `z: volume has no StorageClasses listed`)
695 // If StorageClasses are configured explicitly, there must be
696 // at least one with Default: true. (Calling one "default" is
698 ldr = testLoader(c, `
709 c.Assert(err, check.ErrorMatches, `there is no default storage class.*`)
712 func (s *LoadSuite) TestPreemptiblePriceFactor(c *check.C) {
723 PreemptiblePriceFactor: 0.5
731 PreemptiblePriceFactor: 0.5
737 Type1.preemptible: # higher price than the auto-added variant would use -- should generate warning
747 Type2.preemptible: # identical to the auto-added variant -- so no warning
754 var logbuf bytes.Buffer
755 cfg, err := testLoader(c, yaml, &logbuf).Load()
756 c.Assert(err, check.IsNil)
757 cc, err := cfg.GetCluster("z1111")
758 c.Assert(err, check.IsNil)
759 c.Check(cc.InstanceTypes["Type1"].Price, check.Equals, 1.23)
760 c.Check(cc.InstanceTypes, check.HasLen, 1)
762 cc, err = cfg.GetCluster("z2222")
763 c.Assert(err, check.IsNil)
764 c.Check(cc.InstanceTypes["Type1"].Preemptible, check.Equals, false)
765 c.Check(cc.InstanceTypes["Type1"].Price, check.Equals, 1.23)
766 c.Check(cc.InstanceTypes["Type1.preemptible"].Preemptible, check.Equals, true)
767 c.Check(cc.InstanceTypes["Type1.preemptible"].Price, check.Equals, 1.23/2)
768 c.Check(cc.InstanceTypes["Type1.preemptible"].ProviderType, check.Equals, "Type1")
769 c.Check(cc.InstanceTypes, check.HasLen, 2)
771 cc, err = cfg.GetCluster("z3333")
772 c.Assert(err, check.IsNil)
773 // Don't overwrite the explicitly configured preemptible variant
774 c.Check(cc.InstanceTypes["Type1.preemptible"].Price, check.Equals, 1.23)
775 c.Check(cc.InstanceTypes, check.HasLen, 4)
776 c.Check(logbuf.String(), check.Matches, `(?ms).*Clusters\.z3333\.InstanceTypes\[Type1\.preemptible\]: already exists, so not automatically adding a preemptible variant of Type1.*`)
777 c.Check(logbuf.String(), check.Not(check.Matches), `(?ms).*Type2\.preemptible.*`)
778 c.Check(logbuf.String(), check.Not(check.Matches), `(?ms).*(z1111|z2222)[^\n]*InstanceTypes.*`)
781 func (s *LoadSuite) TestSourceTimestamp(c *check.C) {
782 conftime, err := time.Parse(time.RFC3339, "2022-03-04T05:06:07-08:00")
783 c.Assert(err, check.IsNil)
784 confdata := `Clusters: {zzzzz: {}}`
785 conffile := c.MkDir() + "/config.yml"
786 ioutil.WriteFile(conffile, []byte(confdata), 0777)
787 tv := unix.NsecToTimeval(conftime.UnixNano())
788 unix.Lutimes(conffile, []unix.Timeval{tv, tv})
789 for _, trial := range []struct {
794 {conffile, conftime},
796 c.Logf("trial: %+v", trial)
797 ldr := NewLoader(strings.NewReader(confdata), ctxlog.TestLogger(c))
798 ldr.Path = trial.configarg
799 cfg, err := ldr.Load()
800 c.Assert(err, check.IsNil)
801 c.Check(cfg.SourceTimestamp, check.Equals, cfg.SourceTimestamp.UTC())
802 c.Check(int(cfg.SourceTimestamp.Sub(trial.expectTime).Seconds()), check.Equals, 0)
805 reg := prometheus.NewRegistry()
806 ldr.RegisterMetrics(reg)
807 enc := expfmt.NewEncoder(&buf, expfmt.FmtText)
808 got, _ := reg.Gather()
809 for _, mf := range got {
812 c.Check(buf.String(), check.Matches, `# HELP .*\n# TYPE .*\narvados_config_source_timestamp_seconds{sha256="83aea5d82eb1d53372cd65c936c60acc1c6ef946e61977bbca7cfea709d201a8"} \Q`+fmt.Sprintf("%g", float64(cfg.SourceTimestamp.UnixNano())/1e9)+`\E\n`)