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

[Gustavo Niemeyer]

Ported schema verification and coercion logic from Python. (!)

[William Reade (fwereade)]

It appears to do what it intends, but I do have a few questions...

[0]

+ path = append(path, "[", "?", "]")
...
+ for i := 0; i != l; i++ {
+ path[len(path)-2] = strconv.Itoa(i)
+ elem, err := c.elem.Coerce(rv.Index(i).Interface(), path)

I wouldn't say this is *unclear*, but I did have to stop and think for a moment. I don't see any code path in which the "?" will actually be used, and I would favour a construction more like:

+ for i := 0; i != l; i++ {
+ itemPath = append(path, "[", strconv.Itoa(i). "]")
+ elem, err := c.elem.Coerce(rv.Index(i).Interface(), itemPath)

Are there benefits to the original approach that I've missed?

[1]

+ vpath := append(path, ".", "?")

Same issue as [0].

[2]

Throughout: c, e, o, v, rv, l, vpath, newk, newv... while, again, these aren't actually unclear in context, they don't really reveal their intention very well (if at all). Are there forces that work against the use of longer variable names?

[3]

Finally, I'm concerned about the potential for drift -- both in Schema itself, and in individual schemas.

A language-agnostic schema format (where we define any given schema OAOO, and load it in both Go and Python) would solve the second problem. The first one is slightly trickier, but we could probably do it by encoding tests as sets of (schema-path, input, expected-error-or-serialized-output); we could then have one SchemaTest *loader* per language, which would replace the existing Schema unit tests -- and hopefully not need to change very much, if at all -- and should be sufficient to prevent drift between the implementations (a new Schema test is just a few files added to an existing directory; if a change is made in Python but not in Go, the next run of the Go tests will expose the issue). We'd still need tests for individual schemas, of course, but they could be done in the same format and share the benefits.

In practice, it may be that any single-language change would cause clear errors, quickly and reliably enough that we wouldn't get value from the extra scaffolding, but I'd need to be convinced of that ;).

review: Needs Information

[Gustavo Niemeyer (niemeyer)]

Thanks for the review William. Some feedback:

[0][1]

Yes, in your suggested model we have to shrink and expand the list on every iteration of the loop, while this is a simple assignment. The Python version works the same way.

[2]

Our strict long variable name policy has lead us to a position that is not entirely nice. I'm still very much for readability, and that's precisely the point in fact. Long names in tight contexts are doing more harm than good in our code base, leading to very long lines that often wrap and easily become difficult to follow.

I still think we should be careful about names, even more when these names have a wider scope, but I'd like to propose we take a different stanza in Go, and attempt to follow the practices and style used by the Go development team itself (in a similar way we use PEP8 in Python). Go also has the advantage of typing and static compilation, so it's easier to infer what something is, and harder to make mistakes.

Just for context, here is an example of long names getting in the way of readability:

    @inlineCallbacks
    def test_machine_cannot_be_removed_if_assigned(self):
        """Verify that a machine cannot be removed before being unassigned"""
        machine_state = yield self.machine_state_manager.add_machine_state()
        service_state = yield self.service_state_manager.add_service_state(
            "wordpress", self.formula_state)
        unit_state = yield service_state.add_unit_state()
        yield unit_state.assign_to_machine(machine_state)
        ex = yield self.assertFailure(
            self.machine_state_manager.remove_machine_state(machine_state.id),
            MachineStateInUse)
        self.assertEqual(ex.machine_id, 0)
        yield unit_state.unassign_from_machine()
        topology = yield self.get_topology()
        self.assertTrue(topology.has_machine("machine-0000000000"))
        removed = yield self.machine_state_manager.remove_machine_state(
            machine_state.id)
        self.assertTrue(removed)
        topology = yield self.get_topology()
        self.assertFalse(topology.has_machine("machine-0000000000"))
        # can do this multiple times
        removed = yield self.machine_state_manager.remove_machine_state(
            machine_state.id)
        self.assertFalse(removed)

[3]

I agree with you on that. I just can't work on this right now, but let's try to go into that direction.

[William Reade (fwereade)]

I'm not entirely convinced by [2] but I'm willing to participate in the experiment. I've filed lp:833906 for [3], and I'm happy to approve.

review: Approve

[Jim Baker (jimbaker)]

+1 It's a nice Rosetta Stone for comparing Python and Go, including how the concept, its implementation, and tests should be idiomatically done in Go. Very nice indeed!

[Jim Baker (jimbaker)]

The above should have been a "approved review"

review: Approve

=== modified file 'schema/schema.go'
--- schema/schema.go	2011-08-23 15:10:42 +0000
+++ schema/schema.go	2011-08-24 23:58:23 +0000
@@ -1,3 +1,357 @@
 package schema
 
-const Nothing = 0
+import (
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// 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 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.
+func Int() Checker {
+	return intC{}
+}
+
+type intC struct{}
+
+func (c intC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	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 typed as a float64.
+func Float() Checker {
+	return floatC{}
+}
+
+type floatC struct{}
+
+func (c floatC) Coerce(v interface{}, path []string) (interface{}, os.Error) {
+	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 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 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}
+}
+
+// String 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.
+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([]interface{}, 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.
+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(map[interface{}]interface{}, 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.
+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(map[string]interface{}, 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.
+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)}
+}
 
=== modified file 'schema/schema_test.go'
--- schema/schema_test.go	2011-08-23 15:10:42 +0000
+++ schema/schema_test.go	2011-08-24 23:58:23 +0000
@@ -2,18 +2,244 @@
 
 import (
 	"testing"
-	"launchpad.net/gocheck"
+	. "launchpad.net/gocheck"
 	"launchpad.net/ensemble/go/schema"
+	"os"
 )
 
 func Test(t *testing.T) {
-	gocheck.TestingT(t)
+	TestingT(t)
 }
 
 type S struct{}
 
-var _ = gocheck.Suite(S{})
-
-func (s *S) TestEmpty(c *gocheck.C) {
-	_ = schema.Nothing
+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`)
+}
+
+func (s *S) TestAny(c *C) {
+	sch := schema.Any()
+
+	out, err := sch.Coerce("foo", aPath)
+	c.Assert(err, IsNil)
+	c.Assert(out, Equals, "foo")
+}
+
+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")
+}
+
+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")
+}
+
+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")
+}
+
+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")
+}
+
+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 "\["`)
+}
+
+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)})
+
+	out, err = sch.Coerce(42, aPath)
+	c.Assert(out, IsNil)
+	c.Assert(err, Matches, "<path>: expected list, got 42")
+
+	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, map[interface{}]interface{}{"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(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, map[string]interface{}{"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(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, map[string]interface{}{"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, map[string]interface{}{"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})
+
+	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`)
+
+	// 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`)
 }