Merge lp:~niemeyer/pyjuju/go-iface-schema into lp:pyjuju/go

[Gustavo Niemeyer]

[William Reade (fwereade)]

Also LGTM

review: Approve

[Kapil Thangavelu (hazmat)]

LGTM, thanks for addressing the naming as well in the subsequent branch. as well as the help in getting the tests running.

review: Approve

=== added directory 'formula'
=== added file 'formula/Makefile'
--- formula/Makefile	1970-01-01 00:00:00 +0000
+++ formula/Makefile	2011-08-26 20:38:37 +0000
@@ -0,0 +1,23 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/ensemble/go/formula
+
+GOFILES=\
+	formula.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/export_test.go'
--- formula/export_test.go	1970-01-01 00:00:00 +0000
+++ formula/export_test.go	2011-08-26 20:38:37 +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-08-26 20:38:37 +0000
@@ -0,0 +1,101 @@
+package formula
+
+import (
+	"fmt"
+	"launchpad.net/ensemble/go/schema"
+	"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
+}
+
+var ifaceSchema = schema.FieldMap(schema.Fields{
+	"interface": schema.String(),
+	"limit":     schema.OneOf(schema.Const(nil), schema.Int()),
+	"optional":  schema.Bool(),
+}, nil)
+
+// 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.M{
+			"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.M)
+	if _, ok := m["limit"]; !ok {
+		m["limit"] = c.limit
+	}
+	if _, ok := m["optional"]; !ok {
+		m["optional"] = false
+	}
+	return ifaceSchema.Coerce(m, path)
+}

=== added file 'formula/formula_test.go'
--- formula/formula_test.go	1970-01-01 00:00:00 +0000
+++ formula/formula_test.go	2011-08-26 20:38:37 +0000
@@ -0,0 +1,86 @@
+package formula_test
+
+import (
+	"testing"
+	. "launchpad.net/gocheck"
+	"launchpad.net/ensemble/go/formula"
+	"launchpad.net/ensemble/go/schema"
+)
+
+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"`)
+}
+
+// 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.M{"interface": "http", "limit": nil, "optional": false})
+
+	// Defaults are properly applied
+	v, err = e.Coerce(schema.M{"interface": "http"}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.M{"interface": "http", "limit": nil, "optional": false})
+
+	v, err = e.Coerce(schema.M{"interface": "http", "limit": 2}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.M{"interface": "http", "limit": int64(2), "optional": false})
+
+	v, err = e.Coerce(schema.M{"interface": "http", "optional": true}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.M{"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.M{"interface": "http", "optional": nil}, path)
+	c.Assert(err, Matches, "<path>.optional: expected bool, got nothing")
+
+	v, err = e.Coerce(schema.M{"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.M{"interface": "http"}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.M{"interface": "http", "limit": int64(1), "optional": false})
+}

=== modified file 'schema/schema.go'
--- schema/schema.go	2011-08-24 23:55:56 +0000
+++ schema/schema.go	2011-08-26 20:38:37 +0000
@@ -9,6 +9,12 @@
 	"strings"
 )
 
+// All map types used in the schema package are of type M.
+type M map[interface{}]interface{}
+
+// All the slice types generated in the schema package are of type L.
+type L []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
@@ -101,14 +107,14 @@
 type boolC struct{}
 
 func (c boolC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
-	if reflect.TypeOf(v).Kind() == reflect.Bool {
+	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 typed as an int64.
+// the same value consistently typed as an int64.
 func Int() Checker {
 	return intC{}
 }
@@ -116,6 +122,9 @@
 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:
@@ -129,7 +138,7 @@
 }
 
 // Int returns a Checker that accepts any float value, and returns
-// the same value typed as a float64.
+// the same value consistently typed as a float64.
 func Float() Checker {
 	return floatC{}
 }
@@ -137,6 +146,9 @@
 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:
@@ -156,7 +168,7 @@
 type stringC struct{}
 
 func (c stringC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
-	if reflect.TypeOf(v).Kind() == reflect.String {
+	if v != nil && reflect.TypeOf(v).Kind() == reflect.String {
 		return reflect.ValueOf(v).String(), nil
 	}
 	return nil, error{"string", v, path}
@@ -172,7 +184,7 @@
 	// 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 reflect.TypeOf(v).Kind() == reflect.String {
+	if v != nil && reflect.TypeOf(v).Kind() == reflect.String {
 		s := reflect.ValueOf(v).String()
 		_, err := regexp.Compile(s)
 		if err != nil {
@@ -183,10 +195,12 @@
 	return nil, error{"regexp string", v, path}
 }
 
-// String returns a Checker that accepts a slice value with values
+// 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.L.
 func List(elem Checker) Checker {
 	return listC{elem}
 }
@@ -204,7 +218,7 @@
 	path = append(path, "[", "?", "]")
 
 	l := rv.Len()
-	out := make([]interface{}, 0, l)
+	out := make(L, 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)
@@ -220,6 +234,8 @@
 // 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.M.
 func Map(key Checker, value Checker) Checker {
 	return mapC{key, value}
 }
@@ -238,7 +254,7 @@
 	vpath := append(path, ".", "?")
 
 	l := rv.Len()
-	out := make(map[interface{}]interface{}, l)
+	out := make(M, l)
 	keys := rv.MapKeys()
 	for i := 0; i != l; i++ {
 		k := keys[i]
@@ -264,6 +280,8 @@
 // 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.M.
 func FieldMap(fields Fields, optional Optional) Checker {
 	return fieldMapC{fields, optional}
 }
@@ -291,7 +309,7 @@
 	vpath := append(path, ".", "?")
 
 	l := rv.Len()
-	out := make(map[string]interface{}, l)
+	out := make(M, l)
 	for k, checker := range c.fields {
 		vpath[len(vpath)-1] = k
 		var value interface{}
@@ -315,6 +333,8 @@
 // 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.M.
 func FieldMapSet(selector string, maps []Checker) Checker {
 	fmaps := make([]fieldMapC, len(maps))
 	for i, m := range maps {

=== modified file 'schema/schema_test.go'
--- schema/schema_test.go	2011-08-24 23:55:56 +0000
+++ schema/schema_test.go	2011-08-26 20:38:37 +0000
@@ -33,6 +33,10 @@
 	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) {
@@ -41,6 +45,10 @@
 	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) {
@@ -73,6 +81,10 @@
 	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) {
@@ -89,6 +101,10 @@
 	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) {
@@ -105,6 +121,10 @@
 	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) {
@@ -117,6 +137,10 @@
 	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) {
@@ -132,18 +156,26 @@
 	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, []interface{}{int64(1), int64(2)})
+	c.Assert(out, Equals, schema.L{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`)
@@ -153,12 +185,16 @@
 	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, map[interface{}]interface{}{"a": int64(1), "b": int64(2)})
+	c.Assert(out, Equals, schema.M{"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")
@@ -182,12 +218,16 @@
 
 	out, err := sch.Coerce(map[string]interface{}{"a": "A", "b": "B"}, aPath)
 	c.Assert(err, IsNil)
-	c.Assert(out, Equals, map[string]interface{}{"a": "A", "b": "B"})
+	c.Assert(out, Equals, schema.M{"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"`)
@@ -199,7 +239,7 @@
 	// b is optional
 	out, err = sch.Coerce(map[string]interface{}{"a": "A"}, aPath)
 	c.Assert(err, IsNil)
-	c.Assert(out, Equals, map[string]interface{}{"a": "A"})
+	c.Assert(out, Equals, schema.M{"a": "A"})
 
 	// First path entry shouldn't have dots in an error message.
 	out, err = sch.Coerce(map[string]bool{"a": true}, nil)
@@ -220,11 +260,11 @@
 
 	out, err := sch.Coerce(map[string]int{"type": 1, "a": 2}, aPath)
 	c.Assert(err, IsNil)
-	c.Assert(out, Equals, map[string]interface{}{"type": 1, "a": 2})
+	c.Assert(out, Equals, schema.M{"type": 1, "a": 2})
 
 	out, err = sch.Coerce(map[string]int{"type": 3, "b": 4}, aPath)
 	c.Assert(err, IsNil)
-	c.Assert(out, Equals, map[string]interface{}{"type": 3, "b": 4})
+	c.Assert(out, Equals, schema.M{"type": 3, "b": 4})
 
 	out, err = sch.Coerce(map[string]int{}, aPath)
 	c.Assert(out, IsNil)
@@ -238,6 +278,14 @@
 	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)