github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/core/config/config_test.go (about)

     1  // Copyright 2017 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package config_test
     5  
     6  import (
     7  	"github.com/juju/collections/set"
     8  	"github.com/juju/schema"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  	"gopkg.in/juju/environschema.v1"
    12  
    13  	"github.com/juju/juju/core/config"
    14  	coretesting "github.com/juju/juju/testing"
    15  )
    16  
    17  type ConfigSuite struct {
    18  	coretesting.BaseSuite
    19  }
    20  
    21  var _ = gc.Suite(&ConfigSuite{})
    22  
    23  var testFields = environschema.Fields{
    24  	"field1": {
    25  		Description: "field 1 description",
    26  		Type:        environschema.Tstring,
    27  		Group:       environschema.EnvironGroup,
    28  	},
    29  	"field2": {
    30  		Description: "field 2 description",
    31  		Type:        environschema.Tstring,
    32  		Group:       environschema.EnvironGroup,
    33  	},
    34  	"field3": {
    35  		Description: "field 3 description",
    36  		Type:        environschema.Tint,
    37  		Group:       environschema.EnvironGroup,
    38  	},
    39  	"field4": {
    40  		Description: "field 4 description",
    41  		Type:        environschema.Tbool,
    42  		Group:       environschema.EnvironGroup,
    43  	},
    44  	"field5": {
    45  		Description: "field 5 description",
    46  		Type:        environschema.Tattrs,
    47  		Group:       environschema.EnvironGroup,
    48  	},
    49  }
    50  
    51  var testDefaults = schema.Defaults{
    52  	"field1": "field 1 default",
    53  	"field3": 42,
    54  }
    55  
    56  func (s *ConfigSuite) TestKnownConfigKeys(c *gc.C) {
    57  	c.Assert(config.KnownConfigKeys(
    58  		testFields), gc.DeepEquals, set.NewStrings("field1", "field2", "field3", "field4", "field5"))
    59  }
    60  
    61  func (s *ConfigSuite) assertNewConfig(c *gc.C) *config.Config {
    62  	cfg, err := config.NewConfig(
    63  		map[string]interface{}{"field2": "field 2 value", "field4": true, "field5": map[string]interface{}{"a": "b"}},
    64  		testFields, testDefaults)
    65  	c.Assert(err, jc.ErrorIsNil)
    66  	return cfg
    67  }
    68  
    69  func (s *ConfigSuite) TestAttributes(c *gc.C) {
    70  	cfg := s.assertNewConfig(c)
    71  	c.Assert(cfg.Attributes(), jc.DeepEquals, config.ConfigAttributes{
    72  		"field1": "field 1 default",
    73  		"field2": "field 2 value",
    74  		"field3": 42,
    75  		"field4": true,
    76  		"field5": map[string]string{"a": "b"},
    77  	})
    78  }
    79  
    80  func (s *ConfigSuite) TestNewConfigUnknownAttribute(c *gc.C) {
    81  	_, err := config.NewConfig(map[string]interface{}{"some-attr": "value"}, nil, nil)
    82  	c.Assert(err, gc.ErrorMatches, `unknown key "some-attr" \(value "value"\)`)
    83  }
    84  
    85  func (s *ConfigSuite) TestAttributesNil(c *gc.C) {
    86  	cfg := (*config.Config)(nil)
    87  	c.Assert(cfg.Attributes(), gc.IsNil)
    88  }
    89  
    90  func (s *ConfigSuite) TestGet(c *gc.C) {
    91  	cfg := s.assertNewConfig(c)
    92  	c.Assert(cfg.Attributes().Get("field1", nil), gc.Equals, "field 1 default")
    93  	c.Assert(cfg.Attributes().Get("missing", "default"), gc.Equals, "default")
    94  }
    95  
    96  func (s *ConfigSuite) TestGetString(c *gc.C) {
    97  	cfg := s.assertNewConfig(c)
    98  	c.Assert(cfg.Attributes().GetString("field1", ""), gc.Equals, "field 1 default")
    99  	c.Assert(cfg.Attributes().GetString("missing", "default"), gc.Equals, "default")
   100  }
   101  
   102  func (s *ConfigSuite) TestGetInt(c *gc.C) {
   103  	cfg := s.assertNewConfig(c)
   104  	c.Assert(cfg.Attributes().GetInt("field3", -1), gc.Equals, 42)
   105  	c.Assert(cfg.Attributes().GetInt("missing", -1), gc.Equals, -1)
   106  }
   107  
   108  func (s *ConfigSuite) TestGetBool(c *gc.C) {
   109  	cfg := s.assertNewConfig(c)
   110  	c.Assert(cfg.Attributes().GetBool("field4", false), gc.Equals, true)
   111  	c.Assert(cfg.Attributes().GetBool("missing", true), gc.Equals, true)
   112  }
   113  
   114  func (s *ConfigSuite) TestGetStringMap(c *gc.C) {
   115  	cfg := s.assertNewConfig(c)
   116  	expected := map[string]string{"a": "b"}
   117  	val, err := cfg.Attributes().GetStringMap("field5", nil)
   118  	c.Assert(err, jc.ErrorIsNil)
   119  	c.Assert(val, jc.DeepEquals, expected)
   120  	val, err = cfg.Attributes().GetStringMap("missing", expected)
   121  	c.Assert(err, jc.ErrorIsNil)
   122  	c.Assert(val, jc.DeepEquals, expected)
   123  }
   124  
   125  func (s *ConfigSuite) TestInvalidStringMap(c *gc.C) {
   126  	cfg := s.assertNewConfig(c)
   127  	_, err := cfg.Attributes().GetStringMap("field1", nil)
   128  	c.Assert(err, gc.ErrorMatches, "string map value of type string not valid")
   129  }