Merge lp:~niemeyer/pyjuju/go-formula-config-validation into lp:pyjuju

[Gustavo Niemeyer]

Formula config in Go port needs validation support

It currently implements parsing of the file, but misses
support for validating values.

[Kapil Thangavelu (hazmat)]

Looks good, +1

review: Approve

=== added directory 'formula'
=== added file 'formula/Makefile'
--- formula/Makefile	1970-01-01 00:00:00 +0000
+++ formula/Makefile	2011-09-06 21:44:45 +0000
@@ -0,0 +1,25 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/ensemble/go/formula
+
+GOFILES=\
+	config.go\
+	formula.go\
+	meta.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+

=== added file 'formula/config.go'
--- formula/config.go	1970-01-01 00:00:00 +0000
+++ formula/config.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,126 @@
+package formula
+
+import (
+	"fmt"
+	"io/ioutil"
+	"launchpad.net/ensemble/go/schema"
+	"launchpad.net/goyaml"
+	"os"
+	"strconv"
+)
+
+// Option represents a single configuration option that is declared
+// as supported by a formula in its config.yaml file.
+type Option struct {
+	Title       string
+	Description string
+	Type        string
+	Default     interface{}
+}
+
+// Config represents the supported configuration options for a formula,
+// as declared in its config.yaml file.
+type Config struct {
+	Options map[string]Option
+}
+
+// ReadConfig reads a config.yaml file and returns its representation.
+func ReadConfig(path string) (config *Config, err os.Error) {
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return
+	}
+	config, err = ParseConfig(data)
+	if err != nil {
+		err = os.NewError(fmt.Sprintf("%s: %s", path, err))
+	}
+	return
+}
+
+// ParseConfig parses the content of a config.yaml file and returns
+// its representation.
+func ParseConfig(data []byte) (config *Config, err os.Error) {
+	raw := make(map[interface{}]interface{})
+	err = goyaml.Unmarshal(data, raw)
+	if err != nil {
+		return
+	}
+	v, err := configSchema.Coerce(raw, nil)
+	if err != nil {
+		return
+	}
+	config = &Config{}
+	config.Options = make(map[string]Option)
+	m := v.(schema.MapType)
+	for name, infov := range m["options"].(schema.MapType) {
+		opt := infov.(schema.MapType)
+		optTitle, _ := opt["title"].(string)
+		optType, _ := opt["type"].(string)
+		optDescr, _ := opt["description"].(string)
+		optDefault, _ := opt["default"]
+		config.Options[name.(string)] = Option{
+			Title:       optTitle,
+			Type:        optType,
+			Description: optDescr,
+			Default:     optDefault,
+		}
+	}
+	return
+}
+
+// Validate processes the values in the input map according to the
+// configuration in config, doing the following operations:
+//
+// - Values are converted from strings to the types defined
+// - Options with default values are introduced for missing keys
+// - Unknown keys and badly typed values are reported as errors
+// 
+func (c *Config) Validate(values map[string]string) (processed map[string]interface{}, err os.Error) {
+	out := make(map[string]interface{})
+	for k, v := range values {
+		opt, ok := c.Options[k]
+		if !ok {
+			return nil, os.NewError(fmt.Sprintf("Unknown configuration option: %q", k))
+		}
+		switch opt.Type {
+		case "string":
+			out[k] = v
+		case "int":
+			i, err := strconv.Atoi64(v)
+			if err != nil {
+				return nil, os.NewError(fmt.Sprintf("Value for %q is not an int: %q", k, v))
+			}
+			out[k] = i
+		case "float":
+			f, err := strconv.Atof64(v)
+			if err != nil {
+				return nil, os.NewError(fmt.Sprintf("Value for %q is not a float: %q", k, v))
+			}
+			out[k] = f
+		default:
+			panic(fmt.Sprintf("Internal error: option type %q is unknown to Validate", opt.Type))
+		}
+	}
+	for k, opt := range c.Options {
+		if _, ok := out[k]; !ok && opt.Default != nil {
+			out[k] = opt.Default
+		}
+	}
+	return out, nil
+}
+
+var optionSchema = schema.FieldMap(
+	schema.Fields{
+		"type":        schema.OneOf(schema.Const("string"), schema.Const("int"), schema.Const("float")),
+		"default":     schema.OneOf(schema.String(), schema.Int(), schema.Float()),
+		"description": schema.String(),
+	},
+	schema.Optional{"default", "description"},
+)
+
+var configSchema = schema.FieldMap(
+	schema.Fields{
+		"options": schema.Map(schema.String(), optionSchema),
+	},
+	nil,
+)

=== added file 'formula/config_test.go'
--- formula/config_test.go	1970-01-01 00:00:00 +0000
+++ formula/config_test.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,153 @@
+package formula_test
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/ensemble/go/formula"
+	"path/filepath"
+)
+
+var sampleConfig = `
+options:
+  title:
+    default: My Title
+    description: A descriptive title used for the service.
+    type: string
+  outlook:
+    description: No default outlook.
+    type: string
+  username:
+    default: admin001
+    description: The name of the initial account (given admin permissions).
+    type: string
+  skill-level:
+    description: A number indicating skill.
+    type: int
+  agility-ratio:
+    description: A number from 0 to 1 indicating agility.
+    type: float
+`
+
+func repoConfig(name string) (path string) {
+	return filepath.Join("testrepo", name, "config.yaml")
+}
+
+func assertDummyConfig(c *C, config *formula.Config) {
+	c.Assert(config.Options["title"], Equals,
+		formula.Option{
+			Default:     "My Title",
+			Description: "A descriptive title used for the service.",
+			Type:        "string",
+		},
+	)
+}
+
+func (s *S) TestReadConfig(c *C) {
+	config, err := formula.ReadConfig(repoConfig("dummy"))
+	c.Assert(err, IsNil)
+	assertDummyConfig(c, config)
+}
+
+func (s *S) TestParseConfig(c *C) {
+	data, err := ioutil.ReadFile(repoConfig("dummy"))
+	c.Assert(err, IsNil)
+
+	config, err := formula.ParseConfig(data)
+	c.Assert(err, IsNil)
+	assertDummyConfig(c, config)
+}
+
+func (s *S) TestConfigErrorWithPath(c *C) {
+	path := filepath.Join(c.MkDir(), "mymeta.yaml")
+
+	_, err := formula.ReadConfig(path)
+	c.Assert(err, Matches, `.*/.*/mymeta\.yaml.*no such file.*`)
+
+	data := `options: {t: {type: foo}}`
+	err = ioutil.WriteFile(path, []byte(data), 0644)
+	c.Assert(err, IsNil)
+
+	_, err = formula.ReadConfig(path)
+	c.Assert(err, Matches, `/.*/mymeta\.yaml: options.t.type: unsupported value`)
+}
+
+func (s *S) TestParseSample(c *C) {
+	config, err := formula.ParseConfig([]byte(sampleConfig))
+	c.Assert(err, IsNil)
+
+	opt := config.Options
+	c.Assert(opt["title"], Equals,
+		formula.Option{
+			Default:     "My Title",
+			Description: "A descriptive title used for the service.",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["outlook"], Equals,
+		formula.Option{
+			Description: "No default outlook.",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["username"], Equals,
+		formula.Option{
+			Default:     "admin001",
+			Description: "The name of the initial account (given admin permissions).",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["skill-level"], Equals,
+		formula.Option{
+			Description: "A number indicating skill.",
+			Type:        "int",
+		},
+	)
+}
+
+func (s *S) TestValidate(c *C) {
+	config, err := formula.ParseConfig([]byte(sampleConfig))
+	c.Assert(err, IsNil)
+
+	input := map[string]string{
+		"title": "Helpful Title",
+		"outlook": "Peachy",
+	}
+
+        // This should include an overridden value, a default and a new value.
+	expected := map[string]interface{}{
+		"title": "Helpful Title",
+		"outlook": "Peachy",
+		"username": "admin001",
+	}
+
+	output, err := config.Validate(input)
+	c.Assert(err, IsNil)
+        c.Assert(output, Equals, expected)
+
+	// Check whether float conversion is working.
+	input["agility-ratio"] = "0.5"
+	input["skill-level"] = "7"
+	expected["agility-ratio"] = 0.5
+	expected["skill-level"] = int64(7)
+	output, err = config.Validate(input)
+	c.Assert(err, IsNil)
+        c.Assert(output, Equals, expected)
+
+	// Check whether float errors are caught.
+	input["agility-ratio"] = "foo"
+	output, err = config.Validate(input)
+	c.Assert(err, Matches, `Value for "agility-ratio" is not a float: "foo"`)
+	input["agility-ratio"] = "0.5"
+
+	// Check whether int errors are caught.
+	input["skill-level"] = "foo"
+	output, err = config.Validate(input)
+	c.Assert(err, Matches, `Value for "skill-level" is not an int: "foo"`)
+	input["skill-level"] = "7"
+
+        // Now try to set a value outside the expected.
+        input["bad"] = "value"
+	output, err = config.Validate(input)
+	c.Assert(output, IsNil)
+	c.Assert(err, Matches, `Unknown configuration option: "bad"`)
+}

=== added file 'formula/export_test.go'
--- formula/export_test.go	1970-01-01 00:00:00 +0000
+++ formula/export_test.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,11 @@
+package formula
+
+import (
+	"launchpad.net/ensemble/go/schema"
+)
+
+// Export meaningful bits for tests only.
+
+func IfaceExpander(limit interface{}) schema.Checker {
+	return ifaceExpander(limit)
+}

=== added file 'formula/formula.go'
--- formula/formula.go	1970-01-01 00:00:00 +0000
+++ formula/formula.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,33 @@
+package formula
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func errorf(format string, args ...interface{}) os.Error {
+	return os.NewError(fmt.Sprintf(format, args...))
+}
+
+// ParseId splits a formula identifier into its constituting parts.
+func ParseId(id string) (namespace string, name string, rev int, err os.Error) {
+	colon := strings.Index(id, ":")
+	if colon == -1 {
+		err = errorf("Missing formula namespace: %q", id)
+		return
+	}
+	dash := strings.LastIndex(id, "-")
+	if dash != -1 {
+		rev, err = strconv.Atoi(id[dash+1:])
+	}
+	if dash == -1 || err != nil {
+		err = errorf("Missing formula revision: %q", id)
+		return
+	}
+	namespace = id[:colon]
+	name = id[colon+1 : dash]
+	return
+}
+

=== added file 'formula/formula_test.go'
--- formula/formula_test.go	1970-01-01 00:00:00 +0000
+++ formula/formula_test.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,59 @@
+package formula_test
+
+import (
+	"io/ioutil"
+	"testing"
+	. "launchpad.net/gocheck"
+	"launchpad.net/ensemble/go/formula"
+	"launchpad.net/goyaml"
+)
+
+
+func Test(t *testing.T) {
+	TestingT(t)
+}
+
+type S struct{}
+
+var _ = Suite(&S{})
+
+func (s *S) TestParseId(c *C) {
+	namespace, name, rev, err := formula.ParseId("local:mysql-21")
+	c.Assert(err, IsNil)
+	c.Assert(namespace, Equals, "local")
+	c.Assert(name, Equals, "mysql")
+	c.Assert(rev, Equals, 21)
+
+	namespace, name, rev, err = formula.ParseId("local:mysql-cluster-21")
+	c.Assert(err, IsNil)
+	c.Assert(namespace, Equals, "local")
+	c.Assert(name, Equals, "mysql-cluster")
+	c.Assert(rev, Equals, 21)
+
+	_, _, _, err = formula.ParseId("foo")
+	c.Assert(err, Matches, `Missing formula namespace: "foo"`)
+
+	_, _, _, err = formula.ParseId("local:foo-x")
+	c.Assert(err, Matches, `Missing formula revision: "local:foo-x"`)
+}
+
+func ReadYaml(path string) map[interface{}]interface{} {
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		panic(err)
+	}
+	m := make(map[interface{}]interface{})
+	err = goyaml.Unmarshal(data, m)
+	if err != nil {
+		panic(err)
+	}
+	return m
+}
+
+func DumpYaml(v interface{}) []byte {
+	data, err := goyaml.Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	return data
+}

=== added file 'formula/meta.go'
--- formula/meta.go	1970-01-01 00:00:00 +0000
+++ formula/meta.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,170 @@
+package formula
+
+import (
+	"fmt"
+	"io/ioutil"
+	"launchpad.net/ensemble/go/schema"
+	"launchpad.net/goyaml"
+	"os"
+)
+
+// Relation represents a single relation defined in the formula
+// metadata.yaml file.
+type Relation struct {
+	Interface string
+	Optional bool
+	Limit int
+}
+
+// Meta represents all the known content that may be defined
+// within a formula's metadata.yaml file.
+type Meta struct {
+	Name        string
+	Revision    int
+	Summary     string
+	Description string
+	Provides    map[string]Relation
+	Requires    map[string]Relation
+	Peers       map[string]Relation
+}
+
+// ReadMeta reads a metadata.yaml file and returns its representation.
+func ReadMeta(path string) (meta *Meta, err os.Error) {
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return
+	}
+	meta, err = ParseMeta(data)
+	if err != nil {
+		err = os.NewError(fmt.Sprintf("%s: %s", path, err))
+	}
+	return
+}
+
+// ParseMeta parses the data of a metadata.yaml file and returns
+// its representation.
+func ParseMeta(data []byte) (meta *Meta, err os.Error) {
+	raw := make(map[interface{}]interface{})
+	err = goyaml.Unmarshal(data, raw)
+	if err != nil {
+		return
+	}
+	v, err := formulaSchema.Coerce(raw, nil)
+	if err != nil {
+		return
+	}
+	m := v.(schema.MapType)
+	meta = &Meta{}
+	meta.Name = m["name"].(string)
+	// Schema decodes as int64, but the int range should be good
+	// enough for revisions.
+	meta.Revision = int(m["revision"].(int64))
+	meta.Summary = m["summary"].(string)
+	meta.Description = m["description"].(string)
+	meta.Provides = parseRelations(m["provides"])
+	meta.Requires = parseRelations(m["requires"])
+	meta.Peers = parseRelations(m["peers"])
+	return
+}
+
+func parseRelations(relations interface{}) map[string]Relation {
+	if relations == nil {
+		return nil
+	}
+	result := make(map[string]Relation)
+	for name, rel := range relations.(schema.MapType) {
+		relMap := rel.(schema.MapType)
+		relation := Relation{}
+		relation.Interface = relMap["interface"].(string)
+		relation.Optional = relMap["optional"].(bool)
+		if relMap["limit"] != nil {
+			// Schema defaults to int64, but we know
+			// the int range should be more than enough.
+			relation.Limit = int(relMap["limit"].(int64))
+		}
+		result[name.(string)] = relation
+	}
+	return result
+}
+
+// Schema coercer that expands the interface shorthand notation.
+// A consistent format is easier to work with than considering the
+// potential difference everywhere.
+//
+// Supports the following variants::
+//
+//   provides:
+//     server: riak
+//     admin: http
+//     foobar:
+//       interface: blah
+//
+//   provides:
+//     server:
+//       interface: mysql
+//       limit:
+//       optional: false
+//
+// In all input cases, the output is the fully specified interface
+// representation as seen in the mysql interface description above.
+func ifaceExpander(limit interface{}) schema.Checker {
+	return ifaceExpC{limit}
+}
+
+type ifaceExpC struct {
+	limit interface{}
+}
+
+var (
+	stringC = schema.String()
+	mapC    = schema.Map(schema.String(), schema.Any())
+)
+
+func (c ifaceExpC) Coerce(v interface{}, path []string) (newv interface{}, err os.Error) {
+	s, err := stringC.Coerce(v, path)
+	if err == nil {
+		newv = schema.MapType{
+			"interface": s,
+			"limit":     c.limit,
+			"optional":  false,
+		}
+		return
+	}
+
+	// Optional values are context-sensitive and/or have
+	// defaults, which is different than what KeyDict can
+	// readily support. So just do it here first, then
+	// coerce to the real schema.
+	v, err = mapC.Coerce(v, path)
+	if err != nil {
+		return
+	}
+	m := v.(schema.MapType)
+	if _, ok := m["limit"]; !ok {
+		m["limit"] = c.limit
+	}
+	if _, ok := m["optional"]; !ok {
+		m["optional"] = false
+	}
+	return ifaceSchema.Coerce(m, path)
+}
+
+var ifaceSchema = schema.FieldMap(schema.Fields{
+	"interface": schema.String(),
+	"limit":     schema.OneOf(schema.Const(nil), schema.Int()),
+	"optional":  schema.Bool(),
+}, nil)
+
+var formulaSchema = schema.FieldMap(
+	schema.Fields{
+		"ensemble":    schema.Const("formula"),
+		"name":        schema.String(),
+		"revision":    schema.Int(),
+		"summary":     schema.String(),
+		"description": schema.String(),
+		"peers":       schema.Map(schema.String(), ifaceExpander(1)),
+		"provides":    schema.Map(schema.String(), ifaceExpander(nil)),
+		"requires":    schema.Map(schema.String(), ifaceExpander(1)),
+	},
+	schema.Optional{"provides", "requires", "peers"},
+)

=== added file 'formula/meta_test.go'
--- formula/meta_test.go	1970-01-01 00:00:00 +0000
+++ formula/meta_test.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,135 @@
+package formula_test
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/ensemble/go/formula"
+	"launchpad.net/ensemble/go/schema"
+	"path/filepath"
+)
+
+func repoMeta(name string) (path string) {
+	return filepath.Join("testrepo", name, "metadata.yaml")
+}
+
+func (s *S) TestReadMeta(c *C) {
+	meta, err := formula.ReadMeta(repoMeta("dummy"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Name, Equals, "dummy")
+	c.Assert(meta.Revision, Equals, 1)
+	c.Assert(meta.Summary, Equals, "That's a dummy formula.")
+	c.Assert(meta.Description, Equals,
+		"This is a longer description which\npotentially contains multiple lines.\n")
+}
+
+func (s *S) TestParseMeta(c *C) {
+	data, err := ioutil.ReadFile(repoMeta("dummy"))
+	c.Assert(err, IsNil)
+
+	meta, err := formula.ParseMeta(data)
+	c.Assert(err, IsNil)
+	c.Assert(meta.Name, Equals, "dummy")
+	c.Assert(meta.Revision, Equals, 1)
+	c.Assert(meta.Summary, Equals, "That's a dummy formula.")
+	c.Assert(meta.Description, Equals,
+		"This is a longer description which\npotentially contains multiple lines.\n")
+}
+
+func (s *S) TestMetaHeader(c *C) {
+	yaml := ReadYaml(repoMeta("dummy"))
+	yaml["ensemble"] = "foo"
+	data := DumpYaml(yaml)
+
+	_, err := formula.ParseMeta(data)
+	c.Assert(err, Matches, `ensemble: expected "formula", got "foo"`)
+}
+
+func (s *S) TestMetaErrorWithPath(c *C) {
+	yaml := ReadYaml(repoMeta("dummy"))
+	yaml["ensemble"] = "foo"
+	data := DumpYaml(yaml)
+
+	path := filepath.Join(c.MkDir(), "mymeta.yaml")
+
+	_, err := formula.ReadMeta(path)
+	c.Assert(err, Matches, `.*/.*/mymeta\.yaml.*no such file.*`)
+
+	err = ioutil.WriteFile(path, data, 0644)
+	c.Assert(err, IsNil)
+
+	_, err = formula.ReadMeta(path)
+	c.Assert(err, Matches, `/.*/mymeta\.yaml: ensemble: expected "formula", got "foo"`)
+}
+
+func (s *S) TestParseMetaRelations(c *C) {
+	meta, err := formula.ReadMeta(repoMeta("mysql"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Provides["server"], Equals, formula.Relation{Interface: "mysql"})
+	c.Assert(meta.Requires, IsNil)
+	c.Assert(meta.Peers, IsNil)
+
+	meta, err = formula.ReadMeta(repoMeta("riak"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Provides["endpoint"], Equals, formula.Relation{Interface: "http"})
+	c.Assert(meta.Provides["admin"], Equals, formula.Relation{Interface: "http"})
+	c.Assert(meta.Peers["ring"], Equals, formula.Relation{Interface: "riak", Limit: 1})
+	c.Assert(meta.Requires, IsNil)
+
+	meta, err = formula.ReadMeta(repoMeta("wordpress"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Provides["url"], Equals, formula.Relation{Interface: "http"})
+	c.Assert(meta.Requires["db"], Equals, formula.Relation{Interface: "mysql", Limit: 1})
+	c.Assert(meta.Requires["cache"], Equals, formula.Relation{Interface: "varnish", Limit: 2, Optional: true})
+	c.Assert(meta.Peers, IsNil)
+
+}
+
+// Test rewriting of a given interface specification into long form.
+//
+// InterfaceExpander uses `coerce` to do one of two things:
+//
+//   - Rewrite shorthand to the long form used for actual storage
+//   - Fills in defaults, including a configurable `limit`
+//
+// This test ensures test coverage on each of these branches, along
+// with ensuring the conversion object properly raises SchemaError
+// exceptions on invalid data.
+func (s *S) TestIfaceExpander(c *C) {
+	e := formula.IfaceExpander(nil)
+
+	path := []string{"<pa", "th>"}
+
+	// Shorthand is properly rewritten
+	v, err := e.Coerce("http", path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.MapType{"interface": "http", "limit": nil, "optional": false})
+
+	// Defaults are properly applied
+	v, err = e.Coerce(schema.MapType{"interface": "http"}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.MapType{"interface": "http", "limit": nil, "optional": false})
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "limit": 2}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.MapType{"interface": "http", "limit": int64(2), "optional": false})
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "optional": true}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.MapType{"interface": "http", "limit": nil, "optional": true})
+
+	// Invalid data raises an error.
+	v, err = e.Coerce(42, path)
+	c.Assert(err, Matches, "<path>: expected map, got 42")
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "optional": nil}, path)
+	c.Assert(err, Matches, "<path>.optional: expected bool, got nothing")
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "limit": "none, really"}, path)
+	c.Assert(err, Matches, "<path>.limit: unsupported value")
+
+	// Can change default limit
+	e = formula.IfaceExpander(1)
+	v, err = e.Coerce(schema.MapType{"interface": "http"}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.MapType{"interface": "http", "limit": int64(1), "optional": false})
+}

=== added directory 'formula/testrepo'
=== added directory 'formula/testrepo/dummy'
=== added file 'formula/testrepo/dummy/.ignored'
--- formula/testrepo/dummy/.ignored	1970-01-01 00:00:00 +0000
+++ formula/testrepo/dummy/.ignored	2011-09-06 21:44:45 +0000
@@ -0,0 +1,1 @@
+#
\ No newline at end of file

=== added directory 'formula/testrepo/dummy/build'
=== added file 'formula/testrepo/dummy/build/ignored'
=== added file 'formula/testrepo/dummy/config.yaml'
--- formula/testrepo/dummy/config.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/dummy/config.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,5 @@
+options:
+  title: {default: My Title, description: A descriptive title used for the service., type: string}
+  outlook: {description: No default outlook., type: string}
+  username: {default: admin001, description: The name of the initial account (given admin permissions)., type: string}
+  skill-level: {description: A number indicating skill., type: int}

=== added directory 'formula/testrepo/dummy/empty'
=== added file 'formula/testrepo/dummy/metadata.yaml'
--- formula/testrepo/dummy/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/dummy/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,7 @@
+ensemble: formula
+name: dummy
+revision: 1
+summary: "That's a dummy formula."
+description: |
+    This is a longer description which
+    potentially contains multiple lines.

=== added directory 'formula/testrepo/dummy/src'
=== added file 'formula/testrepo/dummy/src/hello.c'
--- formula/testrepo/dummy/src/hello.c	1970-01-01 00:00:00 +0000
+++ formula/testrepo/dummy/src/hello.c	2011-09-06 21:44:45 +0000
@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+main()
+{
+    printf ("Hello World!\n");
+    return 0;
+}

=== added directory 'formula/testrepo/mysql'
=== added file 'formula/testrepo/mysql/metadata.yaml'
--- formula/testrepo/mysql/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/mysql/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,7 @@
+ensemble: formula
+name: mysql
+revision: 1
+summary: "Database engine"
+description: "A pretty popular database"
+provides:
+  server: mysql

=== added directory 'formula/testrepo/mysql2'
=== added file 'formula/testrepo/mysql2/metadata.yaml'
--- formula/testrepo/mysql2/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/mysql2/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,11 @@
+ensemble: formula
+name: mysql2
+revision: 1
+summary: "Database engine"
+description: "A pretty popular database"
+provides:
+  prod:
+    interface: mysql
+  dev:
+    interface: mysql
+    limit: 2

=== added directory 'formula/testrepo/new'
=== added file 'formula/testrepo/new/metadata.yaml'
--- formula/testrepo/new/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/new/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,7 @@
+ensemble: formula
+name: sample
+revision: 2
+summary: "That's a sample formula."
+description: |
+    This is a longer description which
+    potentially contains multiple lines.

=== added directory 'formula/testrepo/old'
=== added file 'formula/testrepo/old/metadata.yaml'
--- formula/testrepo/old/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/old/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,7 @@
+ensemble: formula
+name: sample
+revision: 1
+summary: "That's a sample formula."
+description: |
+    This is a longer description which
+    potentially contains multiple lines.

=== added directory 'formula/testrepo/riak'
=== added file 'formula/testrepo/riak/metadata.yaml'
--- formula/testrepo/riak/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/riak/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,13 @@
+ensemble: formula
+name: riak
+revision: 7
+summary: "K/V storage engine"
+description: "Scalable K/V Store in Erlang with Clocks :-)"
+provides:
+  endpoint:
+    interface: http
+  admin:
+    interface: http
+peers:
+  ring:
+    interface: riak

=== added directory 'formula/testrepo/varnish'
=== added file 'formula/testrepo/varnish/metadata.yaml'
--- formula/testrepo/varnish/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/varnish/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,7 @@
+ensemble: formula
+name: varnish
+revision: 1
+summary: "Database engine"
+description: "Another popular database"
+provides:
+  webcache: varnish

=== added directory 'formula/testrepo/varnish2'
=== added directory 'formula/testrepo/varnish2/hooks'
=== added file 'formula/testrepo/varnish2/hooks/install'
--- formula/testrepo/varnish2/hooks/install	1970-01-01 00:00:00 +0000
+++ formula/testrepo/varnish2/hooks/install	2011-09-06 21:44:45 +0000
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo hello world
\ No newline at end of file

=== added file 'formula/testrepo/varnish2/metadata.yaml'
--- formula/testrepo/varnish2/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/varnish2/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,7 @@
+ensemble: formula
+name: varnish
+revision: 1
+summary: "Database engine"
+description: "Another popular database"
+provides:
+  webcache: varnish

=== added directory 'formula/testrepo/wordpress'
=== added file 'formula/testrepo/wordpress/config.yaml'
--- formula/testrepo/wordpress/config.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/wordpress/config.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,3 @@
+options:
+  blog-title: {default: My Title, description: A descriptive title used for the blog., type: string}
+

=== added file 'formula/testrepo/wordpress/metadata.yaml'
--- formula/testrepo/wordpress/metadata.yaml	1970-01-01 00:00:00 +0000
+++ formula/testrepo/wordpress/metadata.yaml	2011-09-06 21:44:45 +0000
@@ -0,0 +1,21 @@
+ensemble: formula
+name: wordpress
+revision: 3
+summary: "Blog engine"
+description: "A pretty popular blog engine"
+provides:
+  url:
+    interface: http
+    limit:
+    optional: false
+requires:
+  db:
+    interface: mysql
+    limit: 1
+    optional: false
+  cache:
+    interface: varnish
+    limit: 2
+    optional: true
+
+

=== added directory 'schema'
=== added file 'schema/Makefile'
--- schema/Makefile	1970-01-01 00:00:00 +0000
+++ schema/Makefile	2011-09-06 21:44:45 +0000
@@ -0,0 +1,23 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/ensemble/go/schema
+
+GOFILES=\
+	schema.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+

=== added file 'schema/schema.go'
--- schema/schema.go	1970-01-01 00:00:00 +0000
+++ schema/schema.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,377 @@
+package schema
+
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// All map types used in the schema package are of type MapType.
+type MapType map[interface{}]interface{}
+
+// All the slice types generated in the schema package are of type ListType.
+type ListType []interface{}
+
+// The Coerce method of the Checker interface is called recursively when
+// v is being validated.  If err is nil, newv is used as the new value
+// at the recursion point.  If err is non-nil, v is taken as invalid and
+// may be either ignored or error out depending on where in the schema
+// checking process the error happened. Checkers like OneOf may continue
+// with an alternative, for instance.
+type Checker interface {
+	Coerce(v interface{}, path []string) (newv interface{}, err os.Error)
+}
+
+type error struct {
+	want string
+	got interface{}
+	path    []string
+}
+
+func (e error) String() string {
+	var path string
+	if e.path[0] == "." {
+		path = strings.Join(e.path[1:], "")
+	} else {
+		path = strings.Join(e.path, "")
+	}
+	if e.want == "" {
+		return fmt.Sprintf("%s: unsupported value", path)
+	}
+	if e.got == nil {
+		return fmt.Sprintf("%s: expected %s, got nothing", path, e.want)
+	}
+	return fmt.Sprintf("%s: expected %s, got %#v", path, e.want, e.got)
+}
+
+// Any returns a Checker that succeeds with any input value and
+// results in the value itself unprocessed.
+func Any() Checker {
+	return anyC{}
+}
+
+type anyC struct{}
+
+func (c anyC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	return v, nil
+}
+
+
+// Const returns a Checker that only succeeds if the input matches
+// value exactly.  The value is compared with reflect.DeepEqual.
+func Const(value interface{}) Checker {
+	return constC{value}
+}
+
+type constC struct {
+	value interface{}
+}
+
+func (c constC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	if reflect.DeepEqual(v, c.value) {
+		return v, nil
+	}
+	return nil, error{fmt.Sprintf("%#v", c.value), v, path}
+}
+
+// OneOf returns a Checker that attempts to Coerce the value with each
+// of the provided checkers. The value returned by the first checker
+// that succeeds will be returned by the OneOf checker itself.  If no
+// checker succeeds, OneOf will return an error on coercion.
+func OneOf(options ...Checker) Checker {
+	return oneOfC{options}
+}
+
+type oneOfC struct {
+	options []Checker
+}
+
+func (c oneOfC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	for _, o := range c.options {
+		newv, err := o.Coerce(v, path)
+		if err == nil {
+			return newv, nil
+		}
+	}
+	return nil, error{path: path}
+}
+
+// Bool returns a Checker that accepts boolean values only.
+func Bool() Checker {
+	return boolC{}
+}
+
+type boolC struct{}
+
+func (c boolC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	if v != nil && reflect.TypeOf(v).Kind() == reflect.Bool {
+		return v, nil
+	}
+	return nil, error{"bool", v, path}
+}
+
+// Int returns a Checker that accepts any integer value, and returns
+// the same value consistently typed as an int64.
+func Int() Checker {
+	return intC{}
+}
+
+type intC struct{}
+
+func (c intC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	if v == nil {
+		return nil, error{"int", v, path}
+	}
+	switch reflect.TypeOf(v).Kind() {
+	case reflect.Int:
+	case reflect.Int8:
+	case reflect.Int16:
+	case reflect.Int32:
+	case reflect.Int64:
+	default:
+		return nil, error{"int", v, path}
+	}
+	return reflect.ValueOf(v).Int(), nil
+}
+
+// Int returns a Checker that accepts any float value, and returns
+// the same value consistently typed as a float64.
+func Float() Checker {
+	return floatC{}
+}
+
+type floatC struct{}
+
+func (c floatC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	if v == nil {
+		return nil, error{"float", v, path}
+	}
+	switch reflect.TypeOf(v).Kind() {
+	case reflect.Float32:
+	case reflect.Float64:
+	default:
+		return nil, error{"float", v, path}
+	}
+	return reflect.ValueOf(v).Float(), nil
+}
+
+
+// String returns a Checker that accepts a string value only and returns
+// it unprocessed.
+func String() Checker {
+	return stringC{}
+}
+
+type stringC struct{}
+
+func (c stringC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	if v != nil && reflect.TypeOf(v).Kind() == reflect.String {
+		return reflect.ValueOf(v).String(), nil
+	}
+	return nil, error{"string", v, path}
+}
+
+func SimpleRegexp() Checker {
+	return sregexpC{}
+}
+
+type sregexpC struct{}
+
+func (c sregexpC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	// XXX The regexp package happens to be extremely simple right now.
+	//     Once exp/regexp goes mainstream, we'll have to update this
+	//     logic to use a more widely accepted regexp subset.
+	if v != nil && reflect.TypeOf(v).Kind() == reflect.String {
+		s := reflect.ValueOf(v).String()
+		_, err := regexp.Compile(s)
+		if err != nil {
+			return nil, error{"valid regexp", s, path}
+		}
+		return v, nil
+	}
+	return nil, error{"regexp string", v, path}
+}
+
+// List returns a Checker that accepts a slice value with values
+// that are processed with the elem checker.  If any element of the
+// provided slice value fails to be processed, processing will stop
+// and return with the obtained error.
+//
+// The coerced output value has type schema.ListType.
+func List(elem Checker) Checker {
+	return listC{elem}
+}
+
+type listC struct {
+	elem Checker
+}
+
+func (c listC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Slice {
+		return nil, error{"list", v, path}
+	}
+
+	path = append(path, "[", "?", "]")
+
+	l := rv.Len()
+	out := make(ListType, 0, l)
+	for i := 0; i != l; i++ {
+		path[len(path)-2] = strconv.Itoa(i)
+		elem, err := c.elem.Coerce(rv.Index(i).Interface(), path)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, elem)
+	}
+	return out, nil
+}
+
+// Map returns a Checker that accepts a map value. Every key and value
+// in the map are processed with the respective checker, and if any
+// value fails to be coerced, processing stops and returns with the
+// underlying error.
+//
+// The coerced output value has type schema.MapType.
+func Map(key Checker, value Checker) Checker {
+	return mapC{key, value}
+}
+
+type mapC struct {
+	key Checker
+	value Checker
+}
+
+func (c mapC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Map {
+		return nil, error{"map", v, path}
+	}
+
+	vpath := append(path, ".", "?")
+
+	l := rv.Len()
+	out := make(MapType, l)
+	keys := rv.MapKeys()
+	for i := 0; i != l; i++ {
+		k := keys[i]
+		newk, err := c.key.Coerce(k.Interface(), path)
+		if err != nil {
+			return nil, err
+		}
+		vpath[len(vpath)-1] = fmt.Sprint(k.Interface())
+		newv, err := c.value.Coerce(rv.MapIndex(k).Interface(), vpath)
+		if err != nil {
+			return nil, err
+		}
+		out[newk] = newv
+	}
+	return out, nil
+}
+
+type Fields map[string]Checker
+type Optional []string
+
+// FieldMap returns a Checker that accepts a map value with defined
+// string keys. Every key has an independent checker associated,
+// and processing will only succeed if all the values succeed
+// individually. If a field fails to be processed, processing stops
+// and returns with the underlying error.
+//
+// The coerced output value has type schema.MapType.
+func FieldMap(fields Fields, optional Optional) Checker {
+	return fieldMapC{fields, optional}
+}
+
+type fieldMapC struct {
+	fields Fields
+	optional []string
+}
+
+func (c fieldMapC) isOptional(key string) bool {
+	for _, k := range c.optional {
+		if k == key {
+			return true
+		}
+	}
+	return false
+}
+
+func (c fieldMapC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Map {
+		return nil, error{"map", v, path}
+	}
+
+	vpath := append(path, ".", "?")
+
+	l := rv.Len()
+	out := make(MapType, l)
+	for k, checker := range c.fields {
+		vpath[len(vpath)-1] = k
+		var value interface{}
+		valuev := rv.MapIndex(reflect.ValueOf(k))
+		if valuev.IsValid() {
+			value = valuev.Interface()
+		} else if c.isOptional(k) {
+			continue
+		}
+		newv, err := checker.Coerce(value, vpath)
+		if err != nil {
+			return nil, err
+		}
+		out[k] = newv
+	}
+	return out, nil
+}
+
+// FieldMapSet returns a Checker that accepts a map value checked
+// against one of several FieldMap checkers.  The actual checker
+// used is the first one whose checker associated with the selector
+// field processes the map correctly. If no checker processes
+// the selector value correctly, an error is returned.
+//
+// The coerced output value has type schema.MapType.
+func FieldMapSet(selector string, maps []Checker) Checker {
+	fmaps := make([]fieldMapC, len(maps))
+	for i, m := range maps {
+		if fmap, ok := m.(fieldMapC); ok {
+			if checker, _ := fmap.fields[selector]; checker == nil {
+				panic("FieldMapSet has a FieldMap with a missing selector")
+			}
+			fmaps[i] = fmap
+		} else {
+			panic("FieldMapSet got a non-FieldMap checker")
+		}
+	}
+	return mapSetC{selector, fmaps}
+}
+
+type mapSetC struct {
+	selector string
+	fmaps []fieldMapC
+}
+
+func (c mapSetC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Map {
+		return nil, error{"map", v, path}
+	}
+
+	var selector interface{}
+	selectorv := rv.MapIndex(reflect.ValueOf(c.selector))
+	if selectorv.IsValid() {
+		selector = selectorv.Interface()
+		for _, fmap := range c.fmaps {
+			_, err := fmap.fields[c.selector].Coerce(selector, path)
+			if err != nil {
+				continue
+			}
+			return fmap.Coerce(v, path)
+		}
+	}
+	return nil, error{"supported selector", selector, append(path, ".", c.selector)}
+}

=== added file 'schema/schema_test.go'
--- schema/schema_test.go	1970-01-01 00:00:00 +0000
+++ schema/schema_test.go	2011-09-06 21:44:45 +0000
@@ -0,0 +1,293 @@
+package schema_test
+
+import (
+	"testing"
+	. "launchpad.net/gocheck"
+	"launchpad.net/ensemble/go/schema"
+	"os"
+)
+
+func Test(t *testing.T) {
+	TestingT(t)
+}
+
+type S struct{}
+
+var _ = Suite(&S{})
+
+type Dummy struct{}
+
+func (d *Dummy) Coerce(value interface{}, path []string) (coerced interface{}, err os.Error) {
+	return "i-am-dummy", nil
+}
+
+var aPath = []string{"<pa", "th>"}
+
+func (s *S) TestConst(c *C) {
+	sch := schema.Const("foo")
+
+	out, err := sch.Coerce("foo", aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, "foo")
+
+	out, err = sch.Coerce(42, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>: expected "foo", got 42`)
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>: expected "foo", got nothing`)
+}
+
+func (s *S) TestAny(c *C) {
+	sch := schema.Any()
+
+	out, err := sch.Coerce("foo", aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, "foo")
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, nil)
+}
+
+func (s *S) TestOneOf(c *C) {
+	sch := schema.OneOf(schema.Const("foo"), schema.Const(42))
+
+	out, err := sch.Coerce("foo", aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, "foo")
+
+	out, err = sch.Coerce(42, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, 42)
+
+	out, err = sch.Coerce("bar", aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>: unsupported value`)
+}
+
+func (s *S) TestBool(c *C) {
+	sch := schema.Bool()
+
+	out, err := sch.Coerce(true, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, true)
+
+	out, err = sch.Coerce(false, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, false)
+
+	out, err = sch.Coerce(1, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected bool, got 1")
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected bool, got nothing")
+}
+
+func (s *S) TestInt(c *C) {
+	sch := schema.Int()
+
+	out, err := sch.Coerce(42, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, int64(42))
+
+	out, err = sch.Coerce(int8(42), aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, int64(42))
+
+	out, err = sch.Coerce(true, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected int, got true")
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected int, got nothing")
+}
+
+func (s *S) TestFloat(c *C) {
+	sch := schema.Float()
+
+	out, err := sch.Coerce(float32(1.0), aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, float64(1.0))
+
+	out, err = sch.Coerce(float64(1.0), aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, float64(1.0))
+
+	out, err = sch.Coerce(true, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected float, got true")
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected float, got nothing")
+}
+
+func (s *S) TestString(c *C) {
+	sch := schema.String()
+
+	out, err := sch.Coerce("foo", aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, "foo")
+
+	out, err = sch.Coerce(true, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected string, got true")
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected string, got nothing")
+}
+
+func (s *S) TestSimpleRegexp(c *C) {
+	sch := schema.SimpleRegexp()
+	out, err := sch.Coerce("[0-9]+", aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, "[0-9]+")
+
+	out, err = sch.Coerce(1, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected regexp string, got 1")
+
+	out, err = sch.Coerce("[", aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>: expected valid regexp, got "\["`)
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>: expected regexp string, got nothing`)
+}
+
+func (s *S) TestList(c *C) {
+	sch := schema.List(schema.Int())
+	out, err := sch.Coerce([]int8{1, 2}, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, schema.ListType{int64(1), int64(2)})
+
+	out, err = sch.Coerce(42, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected list, got 42")
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected list, got nothing")
+
+	out, err = sch.Coerce([]interface{}{1, true}, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>\[1\]: expected int, got true`)
+}
+
+func (s *S) TestMap(c *C) {
+	sch := schema.Map(schema.String(), schema.Int())
+	out, err := sch.Coerce(map[string]interface{}{"a": 1, "b": int8(2)}, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, schema.MapType{"a": int64(1), "b": int64(2)})
+
+	out, err = sch.Coerce(42, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected map, got 42")
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected map, got nothing")
+
+	out, err = sch.Coerce(map[int]int{1: 1}, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected string, got 1")
+
+	out, err = sch.Coerce(map[string]bool{"a": true}, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>\.a: expected int, got 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, IsNil)
+	c.Assert(err, Matches, `a: expected int, got true`)
+}
+
+func (s *S) TestFieldMap(c *C) {
+	fields := schema.Fields{
+		"a": schema.Const("A"),
+		"b": schema.Const("B"),
+	}
+	sch := schema.FieldMap(fields, schema.Optional{"b"})
+
+	out, err := sch.Coerce(map[string]interface{}{"a": "A", "b": "B"}, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, schema.MapType{"a": "A", "b": "B"})
+
+	out, err = sch.Coerce(42, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected map, got 42")
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected map, got nothing")
+
+	out, err = sch.Coerce(map[string]interface{}{"a": "A", "b": "C"}, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>\.b: expected "B", got "C"`)
+
+	out, err = sch.Coerce(map[string]interface{}{"b": "B"}, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>\.a: expected "A", got nothing`)
+
+	// b is optional
+	out, err = sch.Coerce(map[string]interface{}{"a": "A"}, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, schema.MapType{"a": "A"})
+
+	// First path entry shouldn't have dots in an error message.
+	out, err = sch.Coerce(map[string]bool{"a": true}, nil)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `a: expected "A", got true`)
+}
+
+func (s *S) TestSchemaMap(c *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, IsNil)
+	c.Assert(out, Equals, schema.MapType{"type": 1, "a": 2})
+
+	out, err = sch.Coerce(map[string]int{"type": 3, "b": 4}, aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, schema.MapType{"type": 3, "b": 4})
+
+	out, err = sch.Coerce(map[string]int{}, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>\.type: expected supported selector, got nothing`)
+
+	out, err = sch.Coerce(map[string]int{"type": 2}, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>\.type: expected supported selector, got 2`)
+
+	out, err = sch.Coerce(map[string]int{"type": 3, "b": 5}, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>\.b: expected 4, got 5`)
+
+	out, err = sch.Coerce(42, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<path>: expected map, got 42`)
+
+	out, err = sch.Coerce(nil, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, `<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, IsNil)
+	c.Assert(err, Matches, `type: expected supported selector, got nothing`)
+}