func (s *S) TestSchemaMap(c *gc.C) { fields1 := schema.FieldMap(schema.Fields{ "type": schema.Const(1), "a": schema.Const(2), }, nil) fields2 := schema.FieldMap(schema.Fields{ "type": schema.Const(3), "b": schema.Const(4), }, nil) sch := schema.FieldMapSet("type", []schema.Checker{fields1, fields2}) out, err := sch.Coerce(map[string]int{"type": 1, "a": 2}, aPath) c.Assert(err, gc.IsNil) c.Assert(out, gc.DeepEquals, map[string]interface{}{"type": 1, "a": 2}) out, err = sch.Coerce(map[string]int{"type": 3, "b": 4}, aPath) c.Assert(err, gc.IsNil) c.Assert(out, gc.DeepEquals, map[string]interface{}{"type": 3, "b": 4}) out, err = sch.Coerce(map[string]int{}, aPath) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `<path>\.type: expected supported selector, got nothing`) out, err = sch.Coerce(map[string]int{"type": 2}, aPath) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `<path>\.type: expected supported selector, got int\(2\)`) out, err = sch.Coerce(map[string]int{"type": 3, "b": 5}, aPath) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `<path>\.b: expected 4, got int\(5\)`) 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`) // First path entry shouldn't have dots in an error message. out, err = sch.Coerce(map[string]int{"a": 1}, nil) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `type: expected supported selector, got nothing`) }
func (s *S) TestFieldMapDefaultInvalid(c *gc.C) { fields := schema.Fields{ "a": schema.Const("A"), } defaults := schema.Defaults{ "a": "B", } sch := schema.FieldMap(fields, defaults) _, err := sch.Coerce(map[string]interface{}{}, aPath) c.Assert(err, gc.ErrorMatches, `<path>.a: expected "A", got string\("B"\)`) }
// ValidateUnknownAttrs checks the unknown attributes of the config against // the supplied fields and defaults, and returns an error if any fails to // validate. Unknown fields are warned about, but preserved, on the basis // that they are reasonably likely to have been written by or for a version // of juju that does recognise the fields, but that their presence is still // anomalous to some degree and should be flagged (and that there is thereby // a mechanism for observing fields that really are typos etc). func (cfg *Config) ValidateUnknownAttrs(fields schema.Fields, defaults schema.Defaults) (map[string]interface{}, error) { attrs := cfg.UnknownAttrs() checker := schema.FieldMap(fields, defaults) coerced, err := checker.Coerce(attrs, nil) if err != nil { logger.Debugf("coercion failed attributes: %#v, checker: %#v, %v", attrs, checker, err) return nil, err } result := coerced.(map[string]interface{}) for name, value := range attrs { if fields[name] == nil { logger.Warningf("unknown config field %q", name) result[name] = value } } return result, nil }
func (s *S) TestFieldMap(c *gc.C) { fields := schema.Fields{ "a": schema.Const("A"), "b": schema.Const("B"), "c": schema.Const("C"), } defaults := schema.Defaults{ "b": schema.Omit, "c": "C", } sch := schema.FieldMap(fields, defaults) assertFieldMap(c, sch) out, err := sch.Coerce(map[string]interface{}{"a": "A", "b": "B", "d": "D"}, aPath) c.Assert(err, gc.IsNil) c.Assert(out, gc.DeepEquals, map[string]interface{}{"a": "A", "b": "B", "c": "C"}) out, err = sch.Coerce(map[string]interface{}{"a": "A", "d": "D"}, aPath) c.Assert(err, gc.IsNil) c.Assert(out, gc.DeepEquals, map[string]interface{}{"a": "A", "c": "C"}) }
// which are not allowed to change in the lifetime // of an environment. var immutableAttributes = []string{ "name", "type", "firewall-mode", "state-port", "api-port", "bootstrap-timeout", "bootstrap-retry-delay", "bootstrap-addresses-delay", "lxc-use-clone", } var ( withDefaultsChecker = schema.FieldMap(fields, defaults) noDefaultsChecker = schema.FieldMap(fields, alwaysOptional) ) // ValidateUnknownAttrs checks the unknown attributes of the config against // the supplied fields and defaults, and returns an error if any fails to // validate. Unknown fields are warned about, but preserved, on the basis // that they are reasonably likely to have been written by or for a version // of juju that does recognise the fields, but that their presence is still // anomalous to some degree and should be flagged (and that there is thereby // a mechanism for observing fields that really are typos etc). func (cfg *Config) ValidateUnknownAttrs(fields schema.Fields, defaults schema.Defaults) (map[string]interface{}, error) { attrs := cfg.UnknownAttrs() checker := schema.FieldMap(fields, defaults) coerced, err := checker.Coerce(attrs, nil) if err != nil {
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))), "provides": schema.StringMap(ifaceExpander(nil)), "requires": schema.StringMap(ifaceExpander(int64(1))), "revision": schema.Int(), // Obsolete