func (s *ConfigSuite) TestValidateUnknownAttrs(c *gc.C) { s.addJujuFiles(c) 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"\)`) }
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))),
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)