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,
