func (s *S) TestFieldMapBasic(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", } s.sch = schema.FieldMap(fields, defaults) assertFieldMap(c, s.sch) out, err := s.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 = s.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"}) out, err = s.sch.Coerce(123, aPath) c.Assert(err, gc.ErrorMatches, `<path>: expected map, got int\(123\)`) c.Assert(out, gc.Equals, nil) out, err = s.sch.Coerce(map[int]string{}, aPath) c.Assert(err, gc.ErrorMatches, `<path>: expected map\[string], got map\[int]string\(map\[int]string{}\)`) c.Assert(out, gc.Equals, nil) type strKey string out, err = s.sch.Coerce(map[strKey]string{"a": "A"}, aPath) c.Assert(err, gc.ErrorMatches, `<path>: expected map\[string], got map\[schema_test\.strKey]string\(map\[schema_test.strKey]string{"a":"A"}\)`) c.Assert(out, gc.Equals, nil) }
func (s *S) TestOneOf(c *gc.C) { s.sch = schema.OneOf(schema.Const("foo"), schema.Const(42)) out, err := s.sch.Coerce("foo", aPath) c.Assert(err, gc.IsNil) c.Assert(out, gc.Equals, "foo") out, err = s.sch.Coerce(42, aPath) c.Assert(err, gc.IsNil) c.Assert(out, gc.Equals, 42) out, err = s.sch.Coerce("bar", aPath) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `<path>: unexpected value "bar"`) }
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) s.sch = schema.FieldMapSet("type", []schema.Checker{fields1, fields2}) out, err := s.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 = s.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 = s.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 = s.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 = s.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 = s.sch.Coerce(42, aPath) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `<path>: expected map, got int\(42\)`) out, err = s.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 = s.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", } s.sch = schema.FieldMap(fields, defaults) _, err := s.sch.Coerce(map[string]interface{}{}, aPath) c.Assert(err, gc.ErrorMatches, `<path>.a: expected "A", got string\("B"\)`) }
func (s *S) TestStrictFieldMap(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", } s.sch = schema.StrictFieldMap(fields, defaults) assertFieldMap(c, s.sch) out, err := s.sch.Coerce(map[string]interface{}{"a": "A", "b": "B", "d": "D"}, aPath) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `<path>: unknown key "d" \(value "D"\)`) out, err = s.sch.Coerce(map[string]interface{}{"a": "A", "b": "B", "d": "D"}, nil) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `unknown key "d" \(value "D"\)`) }
func (s *S) TestFieldMapInterfaceKey(c *gc.C) { fields := schema.Fields{ "a": schema.Const("A"), } s.sch = schema.FieldMap(fields, nil) out, err := s.sch.Coerce(map[interface{}]interface{}{"a": "A"}, aPath) c.Assert(err, gc.IsNil) c.Check(out, gc.DeepEquals, map[string]interface{}{"a": "A"}) _, err = s.sch.Coerce(map[interface{}]interface{}{1: "A"}, aPath) c.Check(err, gc.ErrorMatches, `<path>: expected map\[string], got map\[interface {}]interface {}\(map\[interface {}]interface {}{1:"A"}\)`) }
func (s *S) TestConst(c *gc.C) { s.sch = schema.Const("foo") out, err := s.sch.Coerce("foo", aPath) c.Assert(err, gc.IsNil) c.Assert(out, gc.Equals, "foo") out, err = s.sch.Coerce(42, aPath) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `<path>: expected "foo", got int\(42\)`) out, err = s.sch.Coerce(nil, aPath) c.Assert(out, gc.IsNil) c.Assert(err, gc.ErrorMatches, `<path>: expected "foo", got nothing`) }
EBS_VolumeType: volumeTypeSsd, }) defaultPools := []*storage.Config{ ebsssdPool, } poolmanager.RegisterDefaultStoragePools(defaultPools) } // ebsProvider creates volume sources which use AWS EBS volumes. type ebsProvider struct{} var _ storage.Provider = (*ebsProvider)(nil) var ebsConfigFields = schema.Fields{ EBS_VolumeType: schema.OneOf( schema.Const(volumeTypeMagnetic), schema.Const(volumeTypeSsd), schema.Const(volumeTypeProvisionedIops), schema.Const(volumeTypeStandard), schema.Const(volumeTypeGp2), schema.Const(volumeTypeIo1), ), EBS_IOPS: schema.ForceInt(), EBS_Encrypted: schema.Bool(), } var ebsConfigChecker = schema.FieldMap( ebsConfigFields, schema.Defaults{ EBS_VolumeType: volumeTypeMagnetic, EBS_IOPS: schema.Omit,
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 t == EBS_ProviderType { return &ebsProvider{env}, nil } return nil, errors.NotFoundf("storage provider %q", t) } // ebsProvider creates volume sources which use AWS EBS volumes. type ebsProvider struct { env *environ } var _ storage.Provider = (*ebsProvider)(nil) var ebsConfigFields = schema.Fields{ EBS_VolumeType: schema.OneOf( schema.Const(volumeTypeMagnetic), schema.Const(volumeTypeSSD), schema.Const(volumeTypeProvisionedIops), schema.Const(volumeTypeStandard), schema.Const(volumeTypeGP2), schema.Const(volumeTypeIO1), ), EBS_IOPS: schema.ForceInt(), EBS_Encrypted: schema.Bool(), } var ebsConfigChecker = schema.FieldMap( ebsConfigFields, schema.Defaults{ EBS_VolumeType: volumeTypeMagnetic, EBS_IOPS: schema.Omit,