func (s *S) TestStringMap(c *gc.C) {
sch := schema.StringMap(schema.Int())
out, err := sch.Coerce(map[string]interface{}{"a": 1, "b": int8(2)}, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.DeepEquals, map[string]interface{}{"a": int64(1), "b": int64(2)})
out, err = sch.Coerce(42, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "<path>: expected map, got int\\(42\\)")
out, err = sch.Coerce(nil, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "<path>: expected map, got nothing")
out, err = sch.Coerce(map[int]int{1: 1}, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "<path>: expected string, got int\\(1\\)")
out, err = sch.Coerce(map[string]bool{"a": true}, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>\.a: expected int, got bool\(true\)`)
// First path entry shouldn't have dots in an error message.
out, err = sch.Coerce(map[string]bool{"a": true}, nil)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `a: expected int, got bool\(true\)`)
}
func (s *S) TestList(c *gc.C) {
sch := schema.List(schema.Int())
out, err := sch.Coerce([]int8{1, 2}, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.DeepEquals, []interface{}{int64(1), int64(2)})
out, err = sch.Coerce(42, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "<path>: expected list, got int\\(42\\)")
out, err = sch.Coerce(nil, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "<path>: expected list, got nothing")
out, err = sch.Coerce([]interface{}{1, true}, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>\[1\]: expected int, got bool\(true\)`)
}
func (*ConfigSuite) TestValidateUnknownAttrs(c *gc.C) {
defer makeFakeHome(c).Restore()
cfg, err := config.New(config.UseDefaults, map[string]interface{}{
"name": "myenv",
"type": "other",
"known": "this",
"unknown": "that",
})
// No fields: all attrs passed through.
attrs, err := cfg.ValidateUnknownAttrs(nil, nil)
c.Assert(err, gc.IsNil)
c.Assert(attrs, gc.DeepEquals, map[string]interface{}{
"known": "this",
"unknown": "that",
})
// Valid field: that and other attrs passed through.
fields := schema.Fields{"known": schema.String()}
attrs, err = cfg.ValidateUnknownAttrs(fields, nil)
c.Assert(err, gc.IsNil)
c.Assert(attrs, gc.DeepEquals, map[string]interface{}{
"known": "this",
"unknown": "that",
})
// Default field: inserted.
fields["default"] = schema.String()
defaults := schema.Defaults{"default": "the other"}
attrs, err = cfg.ValidateUnknownAttrs(fields, defaults)
c.Assert(err, gc.IsNil)
c.Assert(attrs, gc.DeepEquals, map[string]interface{}{
"known": "this",
"unknown": "that",
"default": "the other",
})
// Invalid field: failure.
fields["known"] = schema.Int()
_, err = cfg.ValidateUnknownAttrs(fields, defaults)
c.Assert(err, gc.ErrorMatches, `known: expected int, got string\("this"\)`)
}
func (s *S) TestInt(c *gc.C) {
sch := schema.Int()
out, err := sch.Coerce(42, aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.Equals, int64(42))
out, err = sch.Coerce(int8(42), aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.Equals, int64(42))
out, err = sch.Coerce("42", aPath)
c.Assert(err, gc.IsNil)
c.Assert(out, gc.Equals, int64(42))
out, err = sch.Coerce(true, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `<path>: expected int, got bool\(true\)`)
out, err = sch.Coerce(nil, aPath)
c.Assert(out, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "<path>: expected int, got nothing")
}
if value == nil {
return nil, nil
}
defer option.error(&err, name, value)
if checker := optionTypeCheckers[option.Type]; checker != nil {
if value, err = checker.Coerce(value, nil); err != nil {
return nil, err
}
return value, nil
}
panic(fmt.Errorf("option %q has unknown type %q", name, option.Type))
}
var optionTypeCheckers = map[string]schema.Checker{
"string": schema.String(),
"int": schema.Int(),
"float": schema.Float(),
"boolean": schema.Bool(),
}
// parse returns an appropriately-typed value for the supplied string, or
// returns an error if it cannot be parsed to the correct type.
func (option Option) parse(name, str string) (_ interface{}, err error) {
defer option.error(&err, name, str)
switch option.Type {
case "string":
return str, nil
case "int":
return strconv.ParseInt(str, 10, 64)
case "float":
return strconv.ParseFloat(str, 64)
v, err = mapC.Coerce(v, path)
if err != nil {
return
}
m := v.(map[string]interface{})
if _, ok := m["limit"]; !ok {
m["limit"] = c.limit
}
return ifaceSchema.Coerce(m, path)
}
var ifaceSchema = schema.FieldMap(
schema.Fields{
"interface": schema.String(),
"limit": schema.OneOf(schema.Const(nil), schema.Int()),
"scope": schema.OneOf(schema.Const(string(ScopeGlobal)), schema.Const(string(ScopeContainer))),
"optional": schema.Bool(),
},
schema.Defaults{
"scope": string(ScopeGlobal),
"optional": false,
},
)
var charmSchema = schema.FieldMap(
schema.Fields{
"name": schema.String(),
"summary": schema.String(),
"description": schema.String(),
"peers": schema.StringMap(ifaceExpander(int64(1))),