func (*reflectSuite) TestTypeOf(c *gc.C) {
rtype := rpcreflect.TypeOf(reflect.TypeOf(&Root{}))
c.Assert(rtype.DiscardedMethods(), gc.DeepEquals, []string{
"Discard1",
"Discard2",
"Discard3",
})
expect := map[string]reflect.Type{
"CallbackMethods": reflect.TypeOf(&CallbackMethods{}),
"ChangeAPIMethods": reflect.TypeOf(&ChangeAPIMethods{}),
"DelayedMethods": reflect.TypeOf(&DelayedMethods{}),
"ErrorMethods": reflect.TypeOf(&ErrorMethods{}),
"InterfaceMethods": reflect.TypeOf((*InterfaceMethods)(nil)).Elem(),
"SimpleMethods": reflect.TypeOf(&SimpleMethods{}),
}
c.Assert(rtype.MethodNames(), gc.HasLen, len(expect))
for name, expectGoType := range expect {
m, err := rtype.Method(name)
c.Assert(err, jc.ErrorIsNil)
c.Assert(m, gc.NotNil)
c.Assert(m.Call, gc.NotNil)
c.Assert(m.ObjType, gc.Equals, rpcreflect.ObjTypeOf(expectGoType))
c.Assert(m.ObjType.GoType(), gc.Equals, expectGoType)
}
m, err := rtype.Method("not found")
c.Assert(err, gc.Equals, rpcreflect.ErrMethodNotFound)
c.Assert(m, gc.DeepEquals, rpcreflect.RootMethod{})
}
func (*rootSuite) TestDiscardedAPIMethods(c *gc.C) {
t := rpcreflect.TypeOf(apiserver.RootType)
// We must have some root-level methods.
c.Assert(t.MethodNames(), gc.Not(gc.HasLen), 0)
c.Assert(t.DiscardedMethods(), gc.DeepEquals, allowedDiscardedMethods)
for _, name := range t.MethodNames() {
m, err := t.Method(name)
c.Assert(err, gc.IsNil)
// We must have some methods on every object returned
// by a root-level method.
c.Assert(m.ObjType.MethodNames(), gc.Not(gc.HasLen), 0)
// We don't allow any methods that don't implement
// an RPC entry point.
c.Assert(m.ObjType.DiscardedMethods(), gc.HasLen, 0)
}
}