From f236873159a1cd950dc025b1fbe60ff07ae91663 Mon Sep 17 00:00:00 2001 From: Marc Nuri Date: Tue, 18 Nov 2025 11:16:06 +0100 Subject: [PATCH 1/2] feat(config)!: consolidate custom config parsing into config.Extended Signed-off-by: Marc Nuri --- pkg/config/config.go | 79 +++--------------- pkg/config/context.go | 23 ++++++ pkg/config/extended.go | 61 ++++++++++++++ pkg/config/provider_config.go | 53 +----------- pkg/config/provider_config_test.go | 21 ++--- pkg/config/toolset_config.go | 33 +------- pkg/config/toolset_config_test.go | 128 +++++++++++++++++++++++++++++ pkg/kiali/config.go | 4 +- 8 files changed, 238 insertions(+), 164 deletions(-) create mode 100644 pkg/config/context.go create mode 100644 pkg/config/extended.go create mode 100644 pkg/config/toolset_config_test.go diff --git a/pkg/config/config.go b/pkg/config/config.go index 5601e7f0..9586c7c5 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -73,9 +73,9 @@ type StaticConfig struct { ToolsetConfigs map[string]toml.Primitive `toml:"toolset_configs,omitempty"` // Internal: parsed provider configs (not exposed to TOML package) - parsedClusterProviderConfigs map[string]ProviderConfig + parsedClusterProviderConfigs map[string]Extended // Internal: parsed toolset configs (not exposed to TOML package) - parsedToolsetConfigs map[string]ToolsetConfig + parsedToolsetConfigs map[string]Extended // Internal: the config.toml directory, to help resolve relative file paths configDirPath string @@ -129,87 +129,28 @@ func ReadToml(configData []byte, opts ...ReadConfigOpt) (*StaticConfig, error) { opt(config) } - if err := config.parseClusterProviderConfigs(md); err != nil { + ctx := withConfigDirPath(context.Background(), config.configDirPath) + + config.parsedClusterProviderConfigs, err = providerConfigRegistry.Parse(ctx, md, config.ClusterProviderConfigs) + if err != nil { return nil, err } - if err := config.parseToolsetConfigs(md); err != nil { + config.parsedToolsetConfigs, err = toolsetConfigRegistry.Parse(ctx, md, config.ToolsetConfigs) + if err != nil { return nil, err } return config, nil } -func (c *StaticConfig) GetProviderConfig(strategy string) (ProviderConfig, bool) { +func (c *StaticConfig) GetProviderConfig(strategy string) (Extended, bool) { config, ok := c.parsedClusterProviderConfigs[strategy] return config, ok } -func (c *StaticConfig) parseClusterProviderConfigs(md toml.MetaData) error { - if c.parsedClusterProviderConfigs == nil { - c.parsedClusterProviderConfigs = make(map[string]ProviderConfig, len(c.ClusterProviderConfigs)) - } - - ctx := withConfigDirPath(context.Background(), c.configDirPath) - - for strategy, primitive := range c.ClusterProviderConfigs { - parser, ok := getProviderConfigParser(strategy) - if !ok { - continue - } - - providerConfig, err := parser(ctx, primitive, md) - if err != nil { - return fmt.Errorf("failed to parse config for ClusterProvider '%s': %w", strategy, err) - } - - if err := providerConfig.Validate(); err != nil { - return fmt.Errorf("invalid config file for ClusterProvider '%s': %w", strategy, err) - } - - c.parsedClusterProviderConfigs[strategy] = providerConfig - } - - return nil -} - -func (c *StaticConfig) parseToolsetConfigs(md toml.MetaData) error { - if c.parsedToolsetConfigs == nil { - c.parsedToolsetConfigs = make(map[string]ToolsetConfig, len(c.ToolsetConfigs)) - } - - ctx := withConfigDirPath(context.Background(), c.configDirPath) - - for name, primitive := range c.ToolsetConfigs { - parser, ok := getToolsetConfigParser(name) - if !ok { - continue - } - - toolsetConfig, err := parser(ctx, primitive, md) - if err != nil { - return fmt.Errorf("failed to parse config for Toolset '%s': %w", name, err) - } - - if err := toolsetConfig.Validate(); err != nil { - return fmt.Errorf("invalid config file for Toolset '%s': %w", name, err) - } - - c.parsedToolsetConfigs[name] = toolsetConfig - } - - return nil -} - -func (c *StaticConfig) GetToolsetConfig(name string) (ToolsetConfig, bool) { +func (c *StaticConfig) GetToolsetConfig(name string) (Extended, bool) { cfg, ok := c.parsedToolsetConfigs[name] return cfg, ok } - -func (c *StaticConfig) SetToolsetConfig(name string, cfg ToolsetConfig) { - if c.parsedToolsetConfigs == nil { - c.parsedToolsetConfigs = make(map[string]ToolsetConfig) - } - c.parsedToolsetConfigs[name] = cfg -} diff --git a/pkg/config/context.go b/pkg/config/context.go new file mode 100644 index 00000000..e5dbd8d6 --- /dev/null +++ b/pkg/config/context.go @@ -0,0 +1,23 @@ +package config + +import "context" + +type configDirPathKey struct{} + +func withConfigDirPath(ctx context.Context, dirPath string) context.Context { + return context.WithValue(ctx, configDirPathKey{}, dirPath) +} + +func ConfigDirPathFromContext(ctx context.Context) string { + val := ctx.Value(configDirPathKey{}) + + if val == nil { + return "" + } + + if strVal, ok := val.(string); ok { + return strVal + } + + return "" +} diff --git a/pkg/config/extended.go b/pkg/config/extended.go new file mode 100644 index 00000000..b1e238d1 --- /dev/null +++ b/pkg/config/extended.go @@ -0,0 +1,61 @@ +package config + +import ( + "context" + "fmt" + + "github.com/BurntSushi/toml" +) + +// Extended is the interface that all configuration extensions must implement. +// Each extended config manager registers a factory function to parse its config from TOML primitives +type Extended interface { + Validate() error +} + +type ExtendedConfigParser func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (Extended, error) + +type ExtendedConfigRegistry struct { + parsers map[string]ExtendedConfigParser +} + +func NewExtendedConfigRegistry() *ExtendedConfigRegistry { + return &ExtendedConfigRegistry{ + parsers: make(map[string]ExtendedConfigParser), + } +} + +func (r *ExtendedConfigRegistry) Register(name string, parser ExtendedConfigParser) { + if _, exists := r.parsers[name]; exists { + panic("extended config parser already registered for name: " + name) + } + + r.parsers[name] = parser +} + +func (r *ExtendedConfigRegistry) Parse(ctx context.Context, metaData toml.MetaData, configs map[string]toml.Primitive) (map[string]Extended, error) { + if len(configs) == 0 { + return make(map[string]Extended), nil + } + parsedConfigs := make(map[string]Extended, len(configs)) + + for name, primitive := range configs { + parser, ok := r.parsers[name] + if !ok { + continue + } + + extendedConfig, err := parser(ctx, primitive, metaData) + if err != nil { + return nil, fmt.Errorf("failed to parse extended config for '%s': %w", name, err) + } + + if err = extendedConfig.Validate(); err != nil { + return nil, fmt.Errorf("failed to validate extended config for '%s': %w", name, err) + } + + parsedConfigs[name] = extendedConfig + } + + return parsedConfigs, nil +} diff --git a/pkg/config/provider_config.go b/pkg/config/provider_config.go index 45dd2f8d..a4384c1d 100644 --- a/pkg/config/provider_config.go +++ b/pkg/config/provider_config.go @@ -1,54 +1,7 @@ package config -import ( - "context" - "fmt" +var providerConfigRegistry = NewExtendedConfigRegistry() - "github.com/BurntSushi/toml" -) - -// ProviderConfig is the interface that all provider-specific configurations must implement. -// Each provider registers a factory function to parse its config from TOML primitives -type ProviderConfig interface { - Validate() error -} - -type ProviderConfigParser func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (ProviderConfig, error) - -type configDirPathKey struct{} - -func withConfigDirPath(ctx context.Context, dirPath string) context.Context { - return context.WithValue(ctx, configDirPathKey{}, dirPath) -} - -func ConfigDirPathFromContext(ctx context.Context) string { - val := ctx.Value(configDirPathKey{}) - - if val == nil { - return "" - } - - if strVal, ok := val.(string); ok { - return strVal - } - - return "" -} - -var ( - providerConfigParsers = make(map[string]ProviderConfigParser) -) - -func RegisterProviderConfig(strategy string, parser ProviderConfigParser) { - if _, exists := providerConfigParsers[strategy]; exists { - panic(fmt.Sprintf("provider config parser already registered for strategy '%s'", strategy)) - } - - providerConfigParsers[strategy] = parser -} - -func getProviderConfigParser(strategy string) (ProviderConfigParser, bool) { - provider, ok := providerConfigParsers[strategy] - - return provider, ok +func RegisterProviderConfig(name string, parser ExtendedConfigParser) { + providerConfigRegistry.Register(name, parser) } diff --git a/pkg/config/provider_config_test.go b/pkg/config/provider_config_test.go index 84902da4..9dec947a 100644 --- a/pkg/config/provider_config_test.go +++ b/pkg/config/provider_config_test.go @@ -12,21 +12,16 @@ import ( type ProviderConfigSuite struct { BaseConfigSuite - originalProviderConfigParsers map[string]ProviderConfigParser + originalProviderConfigRegistry *ExtendedConfigRegistry } func (s *ProviderConfigSuite) SetupTest() { - s.originalProviderConfigParsers = make(map[string]ProviderConfigParser) - for k, v := range providerConfigParsers { - s.originalProviderConfigParsers[k] = v - } + s.originalProviderConfigRegistry = providerConfigRegistry + providerConfigRegistry = NewExtendedConfigRegistry() } func (s *ProviderConfigSuite) TearDownTest() { - providerConfigParsers = make(map[string]ProviderConfigParser) - for k, v := range s.originalProviderConfigParsers { - providerConfigParsers[k] = v - } + providerConfigRegistry = s.originalProviderConfigRegistry } type ProviderConfigForTest struct { @@ -35,7 +30,7 @@ type ProviderConfigForTest struct { IntProp int `toml:"int_prop"` } -var _ ProviderConfig = (*ProviderConfigForTest)(nil) +var _ Extended = (*ProviderConfigForTest)(nil) func (p *ProviderConfigForTest) Validate() error { if p.StrProp == "force-error" { @@ -44,7 +39,7 @@ func (p *ProviderConfigForTest) Validate() error { return nil } -func providerConfigForTestParser(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (ProviderConfig, error) { +func providerConfigForTestParser(_ context.Context, primitive toml.Primitive, md toml.MetaData) (Extended, error) { var providerConfigForTest ProviderConfigForTest if err := md.PrimitiveDecode(primitive, &providerConfigForTest); err != nil { return nil, err @@ -133,7 +128,7 @@ func (s *ProviderConfigSuite) TestReadConfigUnregisteredProviderConfig() { } func (s *ProviderConfigSuite) TestReadConfigParserError() { - RegisterProviderConfig("test", func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (ProviderConfig, error) { + RegisterProviderConfig("test", func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (Extended, error) { return nil, errors.New("parser error forced by test") }) invalidConfigPath := s.writeConfig(` @@ -156,7 +151,7 @@ func (s *ProviderConfigSuite) TestReadConfigParserError() { func (s *ProviderConfigSuite) TestConfigDirPathInContext() { var capturedDirPath string - RegisterProviderConfig("test", func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (ProviderConfig, error) { + RegisterProviderConfig("test", func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (Extended, error) { capturedDirPath = ConfigDirPathFromContext(ctx) var providerConfigForTest ProviderConfigForTest if err := md.PrimitiveDecode(primitive, &providerConfigForTest); err != nil { diff --git a/pkg/config/toolset_config.go b/pkg/config/toolset_config.go index fb230e71..b8bd972f 100644 --- a/pkg/config/toolset_config.go +++ b/pkg/config/toolset_config.go @@ -1,34 +1,7 @@ package config -import ( - "context" - "fmt" +var toolsetConfigRegistry = NewExtendedConfigRegistry() - "github.com/BurntSushi/toml" -) - -// ToolsetConfig is the interface that all toolset-specific configurations must implement. -// Each toolset registers a factory function to parse its config from TOML primitives -type ToolsetConfig interface { - Validate() error -} - -type ToolsetConfigParser func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (ToolsetConfig, error) - -var ( - toolsetConfigParsers = make(map[string]ToolsetConfigParser) -) - -func RegisterToolsetConfig(name string, parser ToolsetConfigParser) { - if _, exists := toolsetConfigParsers[name]; exists { - panic(fmt.Sprintf("toolset config parser already registered for toolset '%s'", name)) - } - - toolsetConfigParsers[name] = parser -} - -func getToolsetConfigParser(name string) (ToolsetConfigParser, bool) { - parser, ok := toolsetConfigParsers[name] - - return parser, ok +func RegisterToolsetConfig(name string, parser ExtendedConfigParser) { + toolsetConfigRegistry.Register(name, parser) } diff --git a/pkg/config/toolset_config_test.go b/pkg/config/toolset_config_test.go new file mode 100644 index 00000000..a1c5ef5a --- /dev/null +++ b/pkg/config/toolset_config_test.go @@ -0,0 +1,128 @@ +package config + +import ( + "context" + "errors" + "testing" + + "github.com/BurntSushi/toml" + "github.com/stretchr/testify/suite" +) + +type ToolsetConfigSuite struct { + BaseConfigSuite + originalToolsetConfigRegistry *ExtendedConfigRegistry +} + +func (s *ToolsetConfigSuite) SetupTest() { + s.originalToolsetConfigRegistry = toolsetConfigRegistry + toolsetConfigRegistry = NewExtendedConfigRegistry() +} + +func (s *ToolsetConfigSuite) TearDownTest() { + toolsetConfigRegistry = s.originalToolsetConfigRegistry +} + +type ToolsetConfigForTest struct { + Enabled bool `toml:"enabled"` + Endpoint string `toml:"endpoint"` + Timeout int `toml:"timeout"` +} + +var _ Extended = (*ToolsetConfigForTest)(nil) + +func (t *ToolsetConfigForTest) Validate() error { + if t.Endpoint == "force-error" { + return errors.New("validation error forced by test") + } + return nil +} + +func toolsetConfigForTestParser(_ context.Context, primitive toml.Primitive, md toml.MetaData) (Extended, error) { + var toolsetConfigForTest ToolsetConfigForTest + if err := md.PrimitiveDecode(primitive, &toolsetConfigForTest); err != nil { + return nil, err + } + return &toolsetConfigForTest, nil +} + +func (s *ToolsetConfigSuite) TestRegisterToolsetConfig() { + s.Run("panics when registering duplicate toolset config parser", func() { + s.Panics(func() { + RegisterToolsetConfig("test-toolset", toolsetConfigForTestParser) + RegisterToolsetConfig("test-toolset", toolsetConfigForTestParser) + }, "Expected panic when registering duplicate toolset config parser") + }) +} + +func (s *ToolsetConfigSuite) TestReadConfigValid() { + RegisterToolsetConfig("test-toolset", toolsetConfigForTestParser) + validConfigPath := s.writeConfig(` + [toolset_configs.test-toolset] + enabled = true + endpoint = "https://example.com" + timeout = 30 + `) + + config, err := Read(validConfigPath) + s.Run("returns no error for valid file with registered toolset config", func() { + s.Require().NoError(err, "Expected no error for valid file, got %v", err) + }) + s.Run("returns config for valid file with registered toolset config", func() { + s.Require().NotNil(config, "Expected non-nil config for valid file") + }) + s.Run("parses toolset config correctly", func() { + toolsetConfig, ok := config.GetToolsetConfig("test-toolset") + s.Require().True(ok, "Expected to find toolset config for 'test-toolset'") + s.Require().NotNil(toolsetConfig, "Expected non-nil toolset config for 'test-toolset'") + testToolsetConfig, ok := toolsetConfig.(*ToolsetConfigForTest) + s.Require().True(ok, "Expected toolset config to be of type *ToolsetConfigForTest") + s.Equal(true, testToolsetConfig.Enabled, "Expected Enabled to be true") + s.Equal("https://example.com", testToolsetConfig.Endpoint, "Expected Endpoint to be 'https://example.com'") + s.Equal(30, testToolsetConfig.Timeout, "Expected Timeout to be 30") + }) +} + +func (s *ToolsetConfigSuite) TestReadConfigInvalidToolsetConfig() { + RegisterToolsetConfig("test-toolset", toolsetConfigForTestParser) + invalidConfigPath := s.writeConfig(` + [toolset_configs.test-toolset] + enabled = true + endpoint = "force-error" + timeout = 30 + `) + + config, err := Read(invalidConfigPath) + s.Run("returns error for invalid toolset config", func() { + s.Require().NotNil(err, "Expected error for invalid toolset config, got nil") + s.ErrorContains(err, "validation error forced by test", "Expected validation error from toolset config") + }) + s.Run("returns nil config for invalid toolset config", func() { + s.Nil(config, "Expected nil config for invalid toolset config") + }) +} + +func (s *ToolsetConfigSuite) TestReadConfigUnregisteredToolsetConfig() { + unregisteredConfigPath := s.writeConfig(` + [toolset_configs.unregistered-toolset] + enabled = true + endpoint = "https://example.com" + timeout = 30 + `) + + config, err := Read(unregisteredConfigPath) + s.Run("returns no error for unregistered toolset config", func() { + s.Require().NoError(err, "Expected no error for unregistered toolset config, got %v", err) + }) + s.Run("returns config for unregistered toolset config", func() { + s.Require().NotNil(config, "Expected non-nil config for unregistered toolset config") + }) + s.Run("does not parse unregistered toolset config", func() { + _, ok := config.GetToolsetConfig("unregistered-toolset") + s.Require().False(ok, "Expected no toolset config for unregistered toolset") + }) +} + +func TestToolsetConfig(t *testing.T) { + suite.Run(t, new(ToolsetConfigSuite)) +} diff --git a/pkg/kiali/config.go b/pkg/kiali/config.go index 82e8d7f3..1e64b4b0 100644 --- a/pkg/kiali/config.go +++ b/pkg/kiali/config.go @@ -17,7 +17,7 @@ type Config struct { CertificateAuthority string `toml:"certificate_authority,omitempty"` } -var _ config.ToolsetConfig = (*Config)(nil) +var _ config.Extended = (*Config)(nil) func (c *Config) Validate() error { if c == nil { @@ -36,7 +36,7 @@ func (c *Config) Validate() error { return nil } -func kialiToolsetParser(_ context.Context, primitive toml.Primitive, md toml.MetaData) (config.ToolsetConfig, error) { +func kialiToolsetParser(_ context.Context, primitive toml.Primitive, md toml.MetaData) (config.Extended, error) { var cfg Config if err := md.PrimitiveDecode(primitive, &cfg); err != nil { return nil, err From f47e6ff004cf4bae81c0c42f3b46b21c3d834bad Mon Sep 17 00:00:00 2001 From: Marc Nuri Date: Wed, 19 Nov 2025 11:06:02 +0100 Subject: [PATCH 2/2] review(config)!: consolidate custom config parsing into config.Extended Signed-off-by: Marc Nuri --- pkg/config/config.go | 4 ++-- pkg/config/extended.go | 10 +++++----- pkg/config/provider_config.go | 4 ++-- pkg/config/provider_config_test.go | 4 ++-- pkg/config/toolset_config.go | 4 ++-- pkg/config/toolset_config_test.go | 4 ++-- 6 files changed, 15 insertions(+), 15 deletions(-) diff --git a/pkg/config/config.go b/pkg/config/config.go index 9586c7c5..20695768 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -131,12 +131,12 @@ func ReadToml(configData []byte, opts ...ReadConfigOpt) (*StaticConfig, error) { ctx := withConfigDirPath(context.Background(), config.configDirPath) - config.parsedClusterProviderConfigs, err = providerConfigRegistry.Parse(ctx, md, config.ClusterProviderConfigs) + config.parsedClusterProviderConfigs, err = providerConfigRegistry.parse(ctx, md, config.ClusterProviderConfigs) if err != nil { return nil, err } - config.parsedToolsetConfigs, err = toolsetConfigRegistry.Parse(ctx, md, config.ToolsetConfigs) + config.parsedToolsetConfigs, err = toolsetConfigRegistry.parse(ctx, md, config.ToolsetConfigs) if err != nil { return nil, err } diff --git a/pkg/config/extended.go b/pkg/config/extended.go index b1e238d1..a1f0598d 100644 --- a/pkg/config/extended.go +++ b/pkg/config/extended.go @@ -15,17 +15,17 @@ type Extended interface { type ExtendedConfigParser func(ctx context.Context, primitive toml.Primitive, md toml.MetaData) (Extended, error) -type ExtendedConfigRegistry struct { +type extendedConfigRegistry struct { parsers map[string]ExtendedConfigParser } -func NewExtendedConfigRegistry() *ExtendedConfigRegistry { - return &ExtendedConfigRegistry{ +func newExtendedConfigRegistry() *extendedConfigRegistry { + return &extendedConfigRegistry{ parsers: make(map[string]ExtendedConfigParser), } } -func (r *ExtendedConfigRegistry) Register(name string, parser ExtendedConfigParser) { +func (r *extendedConfigRegistry) register(name string, parser ExtendedConfigParser) { if _, exists := r.parsers[name]; exists { panic("extended config parser already registered for name: " + name) } @@ -33,7 +33,7 @@ func (r *ExtendedConfigRegistry) Register(name string, parser ExtendedConfigPars r.parsers[name] = parser } -func (r *ExtendedConfigRegistry) Parse(ctx context.Context, metaData toml.MetaData, configs map[string]toml.Primitive) (map[string]Extended, error) { +func (r *extendedConfigRegistry) parse(ctx context.Context, metaData toml.MetaData, configs map[string]toml.Primitive) (map[string]Extended, error) { if len(configs) == 0 { return make(map[string]Extended), nil } diff --git a/pkg/config/provider_config.go b/pkg/config/provider_config.go index a4384c1d..2e514d0a 100644 --- a/pkg/config/provider_config.go +++ b/pkg/config/provider_config.go @@ -1,7 +1,7 @@ package config -var providerConfigRegistry = NewExtendedConfigRegistry() +var providerConfigRegistry = newExtendedConfigRegistry() func RegisterProviderConfig(name string, parser ExtendedConfigParser) { - providerConfigRegistry.Register(name, parser) + providerConfigRegistry.register(name, parser) } diff --git a/pkg/config/provider_config_test.go b/pkg/config/provider_config_test.go index 9dec947a..2afbd2d7 100644 --- a/pkg/config/provider_config_test.go +++ b/pkg/config/provider_config_test.go @@ -12,12 +12,12 @@ import ( type ProviderConfigSuite struct { BaseConfigSuite - originalProviderConfigRegistry *ExtendedConfigRegistry + originalProviderConfigRegistry *extendedConfigRegistry } func (s *ProviderConfigSuite) SetupTest() { s.originalProviderConfigRegistry = providerConfigRegistry - providerConfigRegistry = NewExtendedConfigRegistry() + providerConfigRegistry = newExtendedConfigRegistry() } func (s *ProviderConfigSuite) TearDownTest() { diff --git a/pkg/config/toolset_config.go b/pkg/config/toolset_config.go index b8bd972f..33af6a38 100644 --- a/pkg/config/toolset_config.go +++ b/pkg/config/toolset_config.go @@ -1,7 +1,7 @@ package config -var toolsetConfigRegistry = NewExtendedConfigRegistry() +var toolsetConfigRegistry = newExtendedConfigRegistry() func RegisterToolsetConfig(name string, parser ExtendedConfigParser) { - toolsetConfigRegistry.Register(name, parser) + toolsetConfigRegistry.register(name, parser) } diff --git a/pkg/config/toolset_config_test.go b/pkg/config/toolset_config_test.go index a1c5ef5a..86f79c66 100644 --- a/pkg/config/toolset_config_test.go +++ b/pkg/config/toolset_config_test.go @@ -11,12 +11,12 @@ import ( type ToolsetConfigSuite struct { BaseConfigSuite - originalToolsetConfigRegistry *ExtendedConfigRegistry + originalToolsetConfigRegistry *extendedConfigRegistry } func (s *ToolsetConfigSuite) SetupTest() { s.originalToolsetConfigRegistry = toolsetConfigRegistry - toolsetConfigRegistry = NewExtendedConfigRegistry() + toolsetConfigRegistry = newExtendedConfigRegistry() } func (s *ToolsetConfigSuite) TearDownTest() {