Merge lp:~jameinel/gouda/test-create into lp:gouda

[John A Meinel]

Get a reflection system working, and use it to expose CreateDoc.

This is a bit of black magic, but it should be pretty stable, and uses JSON's Unmarshal magic. So while we use reflect to work out what types things should be, we don't have to do the actually JSON <=> type decoding.

[Eric Casteleijn (thisfred)]

exciting stuff!

review: Approve

=== modified file 'test_serv/db_manager.go'
--- test_serv/db_manager.go	2012-10-26 09:24:54 +0000
+++ test_serv/db_manager.go	2012-10-26 16:00:30 +0000
@@ -1,8 +1,10 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	"launchpad.net/gouda/u1db"
+	"reflect"
 )
 
 type DBManager struct {
@@ -35,13 +37,71 @@
 type OpArgs struct {
 	Path string // Path to the DBManager
 	Op   string // Operation to perform
-	Args string // JSON string of arguments to pass to Op
-}
-
-func (dbm *DBManager) Op(args OpArgs, reply *string) error {
-	_, ok := dbm.dbs[args.Path]
+	Args []byte // JSON string of arguments to pass to Op
+}
+
+// Decode the array passed over the wire, and Unmarshal it into types that
+// match the function signature. This returns a []reflect.Value array that is
+// suitable for passing to Method.Call()
+func decodeArgumentArray(funcType reflect.Type, rawJSON []byte) ([]reflect.Value, error) {
+	num_wanted_args := funcType.NumIn()
+	// First we use json.Unmarshal to pull out each argument into a
+	// separate string. JSON already knows how to unmarshall into real
+	// types
+	var rawJSONBits = make([]json.RawMessage, 0, num_wanted_args)
+	if err := json.Unmarshal(rawJSON, &rawJSONBits); err != nil {
+		return nil, fmt.Errorf("Error decoding arguments: %v", err)
+	}
+	if len(rawJSONBits) != num_wanted_args {
+		return nil, fmt.Errorf("Incorrect number of arguments. Wanted %d got %d",
+			num_wanted_args, len(rawJSONBits))
+	}
+	reflect_args := make([]reflect.Value, num_wanted_args)
+	// unmarshall each individual arg into its matching type
+	for i := 0; i < num_wanted_args; i++ {
+		// Create a Value to store the i-th argument
+		v := reflect.New(funcType.In(i))
+		err := json.Unmarshal(rawJSONBits[i], v.Interface())
+		reflect_args[i] = v.Elem()
+		if err != nil {
+			return nil, fmt.Errorf("Failed to encode result: %v", err)
+		}
+	}
+	return reflect_args, nil
+}
+
+func callAndSerializeResult(method reflect.Value, args []reflect.Value) ([]byte, error) {
+	// reflect.Value.Call returns an array of Value objects, so we turn
+	// that back into the real instances, and use json.Marshal to turn it
+	// into a response string.
+	result := method.Call(args)
+	realResult := make([]interface{}, len(result))
+	for i, res := range result {
+		realResult[i] = res.Interface()
+	}
+	reply, err := json.Marshal(realResult)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to encode result: %v", err)
+	}
+	return reply, nil
+}
+
+func (dbm *DBManager) Op(args *OpArgs, reply *[]byte) error {
+	db, ok := dbm.dbs[args.Path]
 	if !ok {
 		return fmt.Errorf("No database at path: %s", args.Path)
 	}
+	v := reflect.ValueOf(db)
+	typeMethod, ok := v.Type().MethodByName(args.Op)
+	if !ok {
+		return fmt.Errorf("No method: %s", args.Op)
+	}
+	method := v.Method(typeMethod.Index)
+	reflectedArgs, err := decodeArgumentArray(method.Type(), args.Args)
+	if err != nil {
+		return err
+	}
+	Logf("Decoded: %+v", reflectedArgs)
+	*reply, err = callAndSerializeResult(method, reflectedArgs)
 	return nil
 }

=== modified file 'test_serv/db_manager_test.go'
--- test_serv/db_manager_test.go	2012-10-26 09:57:39 +0000
+++ test_serv/db_manager_test.go	2012-10-26 16:00:30 +0000
@@ -1,7 +1,9 @@
 package main
 
 import (
+	"encoding/json"
 	. "launchpad.net/gocheck"
+	"launchpad.net/gouda/u1db"
 )
 
 type TestDBManager struct {
@@ -20,8 +22,51 @@
 	s.LoggingFixture.TearDown(c)
 }
 
+func (s *TestDBManager) CreateADB(c *C) {
+	var reply string
+	err := s.dbm.Create(&CreateArgs{Path: "a", Type: "memory", ReplicaUID: "uuid"}, &reply)
+	c.Assert(err, IsNil)
+	c.Assert(reply, Equals, "success")
+}
+
 func (s *TestDBManager) TestRunOpWithoutDB(c *C) {
-	var reply string
-	err := s.dbm.Op(OpArgs{Path: "no-such-path"}, &reply)
+	var reply []byte
+	err := s.dbm.Op(&OpArgs{Path: "no-such-path"}, &reply)
 	c.Check(err, ErrorMatches, "No database at path: no-such-path")
 }
+
+func (s *TestDBManager) TestRunInvalidOp(c *C) {
+	var reply []byte
+	s.CreateADB(c)
+	invalid_op := OpArgs{Path: "a", Op: "NoSuchOperation"}
+	err := s.dbm.Op(&invalid_op, &reply)
+	c.Assert(err, NotNil)
+	c.Assert(err, ErrorMatches, "No method: NoSuchOperation")
+}
+
+func (s *TestDBManager) TestCreateDocInvalidNArgs(c *C) {
+	var reply []byte
+	s.CreateADB(c)
+	create_doc_op := OpArgs{Path: "a", Op: "CreateDoc", Args: []byte("[]")}
+	err := s.dbm.Op(&create_doc_op, &reply)
+	c.Assert(err, ErrorMatches, "Incorrect number of arguments. Wanted 2 got 0")
+}
+
+func (s *TestDBManager) TestCreateDoc(c *C) {
+	var reply []byte
+	s.CreateADB(c)
+	create_doc_op := OpArgs{Path: "a", Op: "CreateDoc", Args: []byte(`[{}, null]`)}
+	err := s.dbm.Op(&create_doc_op, &reply)
+	c.Assert(err, IsNil)
+	var response []json.RawMessage
+	err = json.Unmarshal([]byte(reply), &response)
+	// The second value is the 'error' from the function
+	c.Assert(response, HasLen, 2)
+	c.Assert(string(response[1]), Equals, "null")
+	var doc u1db.Document
+	err = json.Unmarshal(response[0], &doc)
+	c.Assert(err, IsNil)
+	c.Assert(doc.Id, NotNil)
+	c.Assert(doc.Rev, NotNil)
+	c.Assert(doc.HasConflicts, Equals, false)
+}