Merge lp:~jtv/gomaasapi/single-wrapper-class into lp:gomaasapi

[Jeroen T. Vermeulen]

Rearrange JSONObject so its conversions are all in a single class. Prepares for supporting non-JSON data. Also, document more functions.

After this, the JSONObject you get back from a result will also store its original raw HTTP response as []byte. You can then query that root JSONObject, in addition to the types you already get (string, number, array, object, MAAS object, bool), as raw data.

The interfaces have become classes. I also added some documentation along the way, in some cases because things weren't clear to myself and so I thought the next reader would appreciate a note.

A large portion of the diff (which is ginormous, sorry) is accounted for by removing casts between Go types and the jsonX types that formerly wrapped them. We can't have wrapper types that are direct aliases of the contained types any more, since we'll need to store some extra data in JSONObject.

Because there is now just a single wrapper type, it's no longer just MAASObject that knows its Client. Every JSONObject now does. A MAASObject is only constructed on the fly, when you ask for one. Call GetMAASObject() twice on the same JSONObject and you'll get two separate instances (with identical contents of course). Which is probably safer, although if you were modifying MAASObjects in place you may have been asking for trouble anyway.

There is one unfortunate API change: a JSONObject itself can no longer be nil; it can just wrap a nil value. So before using a JSONObject, call IsNil() on it now, instead of comparing it to nil. I hope it's early enough in this API's lifetime that such changes are still feasible.

Jeroen

[Raphaël Badin (rvb)]

Thanks a lot for fixing this (and adding a handful of comment on the existing code). Looks good to me but you need to fix live_example.go (see [5]).

[0]

> I hope it's early enough in this API's lifetime that such changes are still feasible.

I really think it's fine, nothing has been released yet.

[1]

(+303/-323) 8 files modified

A huge diff indeed but this kind of stats looks good to me.

[2]

186 - msg := fmt.Sprintf("Requested %v, got %v.", wantedType, obj.Type())
187 + msg := fmt.Sprintf("Requested %v, got %T.", wantedType, obj.value)

Don't you think that the message here will be a bit confusing? I'd change that to
msg := fmt.Sprintf("Requested type %v, got object %T.", wantedType, obj.value)

[3]

273 +func (obj JSONObject) GetString() (value string, err error) {
[...]
281 +func (obj JSONObject) GetFloat64() (value float64, err error) {
etc.

I think it's more idiomatic to use pointers as method receivers:
func (obj *JSONObject) GetString() (value string, err error) {
func (obj *JSONObject) GetFloat64() (value float64, err error) {
etc.

[3]

359 + _ = JSONObject(arr[0])
and
382 + _ = JSONObject(mp["key"])

I'm a bit confused here, what is this for exactly and why are you simply ignoring the return value?

[4]

+// a JSONObject, so if an API call returns a list of objects "l," you first

I think you want to write 'a list of objects "l", you first' here.

Same kind of typo here:
755 +// in "params." It returns the object's new value as received from the API.
and here:
768 +// "params." It returns the object's new value as received from the API.

[5]

There is a tiny problem in example/live_example.go now, with this fix, it works again: http://paste.ubuntu.com/1636327/

[6]

1021 +func (obj JSONObject) MarshalJSON() ([]byte, error) {
and
1028 +func (obj MAASObject) MarshalJSON() ([]byte, error) {

I think it's worth adding a little comment here to explain that this is to implement the Marshaler interface from the std lib.

review: Approve

[Jeroen T. Vermeulen (jtv)]

Relieved to see that you got through the review and that it's not too bad! My apologies again for producing such a big branch.

—

> 186 - msg := fmt.Sprintf("Requested %v, got %v.", wantedType,
> obj.Type())
> 187 + msg := fmt.Sprintf("Requested %v, got %T.", wantedType,
> obj.value)
>
> Don't you think that the message here will be a bit confusing? I'd change
> that to
> msg := fmt.Sprintf("Requested type %v, got object %T.", wantedType, obj.value)

The %T prints the value's type, not its contents. The code is asymmetric, in that I'm printing a value (%v) for the wanted type but a type (%T) for the actual type; but that's because the parameters are respectively a string containing the requested type, and an example of the actual type. So the message that comes out will be symmetric: "Requested bool, got string."

—

> 273 +func (obj JSONObject) GetString() (value string, err error) {
> [...]
> 281 +func (obj JSONObject) GetFloat64() (value float64, err error) {
> etc.
>
> I think it's more idiomatic to use pointers as method receivers:
> func (obj *JSONObject) GetString() (value string, err error) {
> func (obj *JSONObject) GetFloat64() (value float64, err error) {
> etc.

I don't think it's particularly idiomatic, or the language wouldn't give us this unusual choice in the first place. It's just one of those make-work decisions the language forces on teams, and which seemed like good ideas in the days when code was usually “owned” by one programmer. It can lead to endless discussion, and I wonder if that is what the Go team have in mind when they say they wanted to make programming fun again... The gift that keeps on giving!

JSONObject is small and meant to be used in an immutable fashion, in which case I think not having the pointer is actually clearer. It rules out most of the worries about which change might affect what instances.

If JSONObject were an interface and the objects had, or might become, mutable operations then it would be different: in that case I think only pointers make sense as receiver types.

And there you have it: three different criteria driving the same decision — mutability, copying cost, and interfaces. The situation pretty much rules out full agreement in everyday situations. :(

—

> 359 + _ = JSONObject(arr[0])
> and
> 382 + _ = JSONObject(mp["key"])
>
> I'm a bit confused here, what is this for exactly and why are you simply
> ignoring the return value?

Well spotted. That was meant to be a type assertion. It has _some_ power to do that in its current form, but it's not very effective. I changed it to:

    var _ JSONObject = arr[0]

(mutatis mutandi of course).

—

> +// a JSONObject, so if an API call returns a list of objects "l," you first
>
> I think you want to write 'a list of objects "l", you first' here.
>
> Same kind of typo here:
> 755 +// in "params." It returns the object's new value as received from
> the API.
> and here:
> 768 +// "params." It returns the object's new value as received from the
> API.

Not a typo. Typography. LaTeX, which is a great school for these things, taught me to move a full stop or comma insi...

[MAAS Lander (maas-lander)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Raphaël Badin (rvb)]

> The %T prints the value's type, not its contents. The code is asymmetric, in that I'm printing a value (%v) for the
> wanted type but a type (%T) for the actual type; but that's because the parameters are respectively a string
> containing the requested type, and an example of the actual type. So the message that comes out will be symmetric:
> "Requested bool, got string."

Ah right, I missed that, thanks for the clarification.

> Not a typo. Typography. LaTeX, which is a great school for these things, taught me to move a full stop or comma
> inside the quotes. I do sometimes break that rule when talking about code or other literal strings where it may
> lead to confusion.

> I realize this may be controversial. It's been a while since I last read 1984, but as I recall Winston Smith, after
> the régime breaks him, gets put on a committee to argue this very point. That book was written about 65 years ago,
> so I'm fairly confident without looking that there has been no sudden consensus since that overrules the LaTeX
> rule. :-)

Hum, I did not know about that… and last time I used LaTeX is was less that 3 years ago… I must say this really looks ugly, I'll need to verify this…

> Speaking of controversial commas: I first read this as “There is a tiny problem in example/live_example.go now,
> with this fix. It works again”! That's the problem with using commas to separate sentences: it leaves room for
> ambiguity.

Yeah, sorry for the vague sentence.

=== modified file 'client.go'
--- client.go	2013-02-05 14:27:56 +0000
+++ client.go	2013-02-12 05:49:22 +0000
@@ -19,6 +19,7 @@
 	Signer  OAuthSigner
 }
 
+// dispatchRequest sends a request to the server, and interprets the response.
 func (client Client) dispatchRequest(request *http.Request) ([]byte, error) {
 	client.Signer.OAuthSign(request)
 	httpClient := http.Client{}
@@ -36,10 +37,16 @@
 	return body, nil
 }
 
+// GetURL returns the URL to a given resource on the API, based on its URI.
+// The resource URI may be absolute or relative; either way the result is a
+// full absolute URL including the network part.
 func (client Client) GetURL(uri *url.URL) *url.URL {
 	return client.BaseURL.ResolveReference(uri)
 }
 
+// Get performs an HTTP "GET" to the API.  This may be either an API method
+// invocation (if you pass its name in "operation") or plain resource
+// retrieval (if you leave "operation" blank).
 func (client Client) Get(uri *url.URL, operation string, parameters url.Values) ([]byte, error) {
 	opParameter := parameters.Get("op")
 	if opParameter != "" {
@@ -58,7 +65,8 @@
 	return client.dispatchRequest(request)
 }
 
-// nonIdempotentRequest is a utility method to issue a PUT or a POST request.
+// nonIdempotentRequest implements the common functionality of PUT and POST
+// requests (but not GET or DELETE requests).
 func (client Client) nonIdempotentRequest(method string, uri *url.URL, parameters url.Values) ([]byte, error) {
 	url := client.GetURL(uri)
 	request, err := http.NewRequest(method, url.String(), strings.NewReader(string(parameters.Encode())))
@@ -69,16 +77,21 @@
 	return client.dispatchRequest(request)
 }
 
+// Post performs an HTTP "POST" to the API.  This may be either an API method
+// invocation (if you pass its name in "operation") or plain resource
+// retrieval (if you leave "operation" blank).
 func (client Client) Post(uri *url.URL, operation string, parameters url.Values) ([]byte, error) {
 	queryParams := url.Values{"op": {operation}}
 	uri.RawQuery = queryParams.Encode()
 	return client.nonIdempotentRequest("POST", uri, parameters)
 }
 
+// Put updates an object on the API, using an HTTP "PUT" request.
 func (client Client) Put(uri *url.URL, parameters url.Values) ([]byte, error) {
 	return client.nonIdempotentRequest("PUT", uri, parameters)
 }
 
+// Delete deletes an object on the API, using an HTTP "DELETE" request.
 func (client Client) Delete(uri *url.URL) error {
 	url := client.GetURL(uri)
 	request, err := http.NewRequest("DELETE", url.String(), strings.NewReader(""))
@@ -92,13 +105,14 @@
 	return nil
 }
 
+// Anonymous "signature method" implementation.
 type anonSigner struct{}
 
 func (signer anonSigner) OAuthSign(request *http.Request) error {
 	return nil
 }
 
-// Trick to ensure *anonSigner implements the OAuthSigner interface.
+// *anonSigner implements the OAuthSigner interface.
 var _ OAuthSigner = anonSigner{}
 
 // NewAnonymousClient creates a client that issues anonymous requests.

=== modified file 'example/live_example.go'
--- example/live_example.go	2013-02-05 14:27:56 +0000
+++ example/live_example.go	2013-02-12 05:49:22 +0000
@@ -77,9 +77,7 @@
 	updateParams := url.Values{"hostname": {"mynewname"}}
 	newNodeObj2, err := newNode.Update(updateParams)
 	checkError(err)
-	newNode2, err := newNodeObj2.GetMAASObject()
-	checkError(err)
-	newNodeName2, err := newNode2.GetField("hostname")
+	newNodeName2, err := newNodeObj2.GetField("hostname")
 	checkError(err)
 	fmt.Printf("New node updated, now named: %s\n", newNodeName2)
 

=== modified file 'jsonobject.go'
--- jsonobject.go	2013-02-06 03:54:20 +0000
+++ jsonobject.go	2013-02-12 05:49:22 +0000
@@ -23,79 +23,43 @@
 // There is one exception: a MAASObject is really a special kind of map,
 // so you can read it as either.
 // Reading a null item is also an error.  So before you try obj.Get*(),
-// first check that obj != nil.
-type JSONObject interface {
-	// Type of this value:
-	// "string", "float64", "map", "maasobject", "array", or "bool".
-	Type() string
-	// Read as string.
-	GetString() (string, error)
-	// Read number as float64.
-	GetFloat64() (float64, error)
-	// Read object as map.
-	GetMap() (map[string]JSONObject, error)
-	// Read object as MAAS object.
-	GetMAASObject() (MAASObject, error)
-	// Read list as array.
-	GetArray() ([]JSONObject, error)
-	// Read as bool.
-	GetBool() (bool, error)
+// first check obj.IsNil().
+type JSONObject struct {
+	value  interface{}
+	client Client
 }
 
-// Internally, each JSONObject already knows what type it is.  It just
-// can't tell the caller yet because the caller may not have the right
-// hard-coded variable type.
-// So for each JSON type, there is a separate implementation of JSONObject
-// that converts only to that type.  Any other conversion is an error.
-// One type is special: jsonMAASObject is an object in the MAAS sense.  It
-// behaves just like a jsonMap if you want it to, but it also implements
-// MAASObject.
-type jsonString string
-type jsonFloat64 float64
-type jsonMap map[string]JSONObject
-type jsonArray []JSONObject
-type jsonBool bool
-
 // Our JSON processor distinguishes a MAASObject from a jsonMap by the fact
 // that it contains a key "resource_uri".  (A regular map might contain the
 // same key through sheer coincide, but never mind: you can still treat it
 // as a jsonMap and never notice the difference.)
 const resourceURI = "resource_uri"
 
-// maasify is internal.  It turns a completely untyped json.Unmarshal result
-// into a JSONObject (with the appropriate implementation of course).
-// This function is recursive.  Maps and arrays are deep-copied, with each
-// individual value being converted to a JSONObject type.
+// maasify turns a completely untyped json.Unmarshal result into a JSONObject
+// (with the appropriate implementation of course).  This function is
+// recursive.  Maps and arrays are deep-copied, with each individual value
+// being converted to a JSONObject type.
 func maasify(client Client, value interface{}) JSONObject {
 	if value == nil {
-		return nil
+		return JSONObject{}
 	}
 	switch value.(type) {
-	case string:
-		return jsonString(value.(string))
-	case float64:
-		return jsonFloat64(value.(float64))
+	case string, float64, bool:
+		return JSONObject{value: value}
 	case map[string]interface{}:
 		original := value.(map[string]interface{})
 		result := make(map[string]JSONObject, len(original))
 		for key, value := range original {
 			result[key] = maasify(client, value)
 		}
-		if _, ok := result[resourceURI]; ok {
-			// If the map contains "resource-uri", we can treat
-			// it as a MAAS object.
-			return newJSONMAASObject(result, client)
-		}
-		return jsonMap(result)
+		return JSONObject{value: result, client: client}
 	case []interface{}:
 		original := value.([]interface{})
 		result := make([]JSONObject, len(original))
 		for index, value := range original {
 			result[index] = maasify(client, value)
 		}
-		return jsonArray(result)
-	case bool:
-		return jsonBool(value.(bool))
+		return JSONObject{value: result}
 	}
 	msg := fmt.Sprintf("Unknown JSON type, can't be converted to JSONObject: %v", value)
 	panic(msg)
@@ -106,92 +70,57 @@
 	var obj interface{}
 	err := json.Unmarshal(input, &obj)
 	if err != nil {
-		return nil, err
+		return JSONObject{}, err
 	}
 	return maasify(client, obj), nil
 }
 
 // Return error value for failed type conversion.
 func failConversion(wantedType string, obj JSONObject) error {
-	msg := fmt.Sprintf("Requested %v, got %v.", wantedType, obj.Type())
+	msg := fmt.Sprintf("Requested %v, got %T.", wantedType, obj.value)
 	return errors.New(msg)
 }
 
-// Error return values for failure to convert to string.
-func failString(obj JSONObject) (string, error) {
-	return "", failConversion("string", obj)
-}
-
-// Error return values for failure to convert to float64.
-func failFloat64(obj JSONObject) (float64, error) {
-	return 0.0, failConversion("float64", obj)
-}
-
-// Error return values for failure to convert to map.
-func failMap(obj JSONObject) (map[string]JSONObject, error) {
-	return make(map[string]JSONObject, 0), failConversion("map", obj)
-}
-
-// Error return values for failure to convert to MAAS object.
-func failMAASObject(obj JSONObject) (MAASObject, error) {
-	return jsonMAASObject{}, failConversion("maasobject", obj)
-}
-
-// Error return values for failure to convert to array.
-func failArray(obj JSONObject) ([]JSONObject, error) {
-	return make([]JSONObject, 0), failConversion("array", obj)
-}
-
-// Error return values for failure to convert to bool.
-func failBool(obj JSONObject) (bool, error) {
-	return false, failConversion("bool", obj)
-}
-
-// JSONObject implementation for jsonString.
-func (jsonString) Type() string                               { return "string" }
-func (obj jsonString) GetString() (string, error)             { return string(obj), nil }
-func (obj jsonString) GetFloat64() (float64, error)           { return failFloat64(obj) }
-func (obj jsonString) GetMap() (map[string]JSONObject, error) { return failMap(obj) }
-func (obj jsonString) GetMAASObject() (MAASObject, error)     { return failMAASObject(obj) }
-func (obj jsonString) GetArray() ([]JSONObject, error)        { return failArray(obj) }
-func (obj jsonString) GetBool() (bool, error)                 { return failBool(obj) }
-
-// JSONObject implementation for jsonFloat64.
-func (jsonFloat64) Type() string                               { return "float64" }
-func (obj jsonFloat64) GetString() (string, error)             { return failString(obj) }
-func (obj jsonFloat64) GetFloat64() (float64, error)           { return float64(obj), nil }
-func (obj jsonFloat64) GetMap() (map[string]JSONObject, error) { return failMap(obj) }
-func (obj jsonFloat64) GetMAASObject() (MAASObject, error)     { return failMAASObject(obj) }
-func (obj jsonFloat64) GetArray() ([]JSONObject, error)        { return failArray(obj) }
-func (obj jsonFloat64) GetBool() (bool, error)                 { return failBool(obj) }
-
-// JSONObject implementation for jsonMap.
-func (jsonMap) Type() string                     { return "map" }
-func (obj jsonMap) GetString() (string, error)   { return failString(obj) }
-func (obj jsonMap) GetFloat64() (float64, error) { return failFloat64(obj) }
-func (obj jsonMap) GetMap() (map[string]JSONObject, error) {
-	return (map[string]JSONObject)(obj), nil
-}
-func (obj jsonMap) GetMAASObject() (MAASObject, error) { return failMAASObject(obj) }
-func (obj jsonMap) GetArray() ([]JSONObject, error)    { return failArray(obj) }
-func (obj jsonMap) GetBool() (bool, error)             { return failBool(obj) }
-
-// JSONObject implementation for jsonArray.
-func (jsonArray) Type() string                               { return "array" }
-func (obj jsonArray) GetString() (string, error)             { return failString(obj) }
-func (obj jsonArray) GetFloat64() (float64, error)           { return failFloat64(obj) }
-func (obj jsonArray) GetMap() (map[string]JSONObject, error) { return failMap(obj) }
-func (obj jsonArray) GetMAASObject() (MAASObject, error)     { return failMAASObject(obj) }
-func (obj jsonArray) GetArray() ([]JSONObject, error) {
-	return ([]JSONObject)(obj), nil
-}
-func (obj jsonArray) GetBool() (bool, error) { return failBool(obj) }
-
-// JSONObject implementation for jsonBool.
-func (jsonBool) Type() string                               { return "bool" }
-func (obj jsonBool) GetString() (string, error)             { return failString(obj) }
-func (obj jsonBool) GetFloat64() (float64, error)           { return failFloat64(obj) }
-func (obj jsonBool) GetMap() (map[string]JSONObject, error) { return failMap(obj) }
-func (obj jsonBool) GetMAASObject() (MAASObject, error)     { return failMAASObject(obj) }
-func (obj jsonBool) GetArray() ([]JSONObject, error)        { return failArray(obj) }
-func (obj jsonBool) GetBool() (bool, error)                 { return bool(obj), nil }
+func (obj JSONObject) IsNil() bool {
+	return obj.value == nil
+}
+
+func (obj JSONObject) GetString() (value string, err error) {
+	value, ok := obj.value.(string)
+	if !ok {
+		err = failConversion("string", obj)
+	}
+	return
+}
+
+func (obj JSONObject) GetFloat64() (value float64, err error) {
+	value, ok := obj.value.(float64)
+	if !ok {
+		err = failConversion("float64", obj)
+	}
+	return
+}
+
+func (obj JSONObject) GetMap() (value map[string]JSONObject, err error) {
+	value, ok := obj.value.(map[string]JSONObject)
+	if !ok {
+		err = failConversion("map", obj)
+	}
+	return
+}
+
+func (obj JSONObject) GetArray() (value []JSONObject, err error) {
+	value, ok := obj.value.([]JSONObject)
+	if !ok {
+		err = failConversion("array", obj)
+	}
+	return
+}
+
+func (obj JSONObject) GetBool() (value bool, err error) {
+	value, ok := obj.value.(bool)
+	if !ok {
+		err = failConversion("bool", obj)
+	}
+	return
+}

=== modified file 'jsonobject_test.go'
--- jsonobject_test.go	2013-02-05 14:35:15 +0000
+++ jsonobject_test.go	2013-02-12 05:49:22 +0000
@@ -14,49 +14,59 @@
 
 // maasify() converts nil.
 func (suite *JSONObjectSuite) TestMaasifyConvertsNil(c *C) {
-	c.Check(maasify(Client{}, nil), Equals, nil)
+	c.Check(maasify(Client{}, nil).IsNil(), Equals, true)
 }
 
 // maasify() converts strings.
 func (suite *JSONObjectSuite) TestMaasifyConvertsString(c *C) {
 	const text = "Hello"
-	c.Check(string(maasify(Client{}, text).(jsonString)), Equals, text)
+	out, err := maasify(Client{}, text).GetString()
+	c.Assert(err, IsNil)
+	c.Check(out, Equals, text)
 }
 
 // maasify() converts float64 numbers.
 func (suite *JSONObjectSuite) TestMaasifyConvertsNumber(c *C) {
 	const number = 3.1415926535
-	c.Check(float64(maasify(Client{}, number).(jsonFloat64)), Equals, number)
+	num, err := maasify(Client{}, number).GetFloat64()
+	c.Assert(err, IsNil)
+	c.Check(num, Equals, number)
 }
 
 // maasify() converts array slices.
 func (suite *JSONObjectSuite) TestMaasifyConvertsArray(c *C) {
 	original := []interface{}{3.0, 2.0, 1.0}
-	output := maasify(Client{}, original).(jsonArray)
+	output, err := maasify(Client{}, original).GetArray()
+	c.Assert(err, IsNil)
 	c.Check(len(output), Equals, len(original))
 }
 
 // When maasify() converts an array slice, the result contains JSONObjects.
 func (suite *JSONObjectSuite) TestMaasifyArrayContainsJSONObjects(c *C) {
-	arr := maasify(Client{}, []interface{}{9.9}).(jsonArray)
-	var entry JSONObject
-	entry = arr[0]
-	c.Check((float64)(entry.(jsonFloat64)), Equals, 9.9)
+	arr, err := maasify(Client{}, []interface{}{9.9}).GetArray()
+	c.Assert(err, IsNil)
+	var _ JSONObject = arr[0]
+	entry, err := arr[0].GetFloat64()
+	c.Assert(err, IsNil)
+	c.Check(entry, Equals, 9.9)
 }
 
 // maasify() converts maps.
 func (suite *JSONObjectSuite) TestMaasifyConvertsMap(c *C) {
 	original := map[string]interface{}{"1": "one", "2": "two", "3": "three"}
-	output := maasify(Client{}, original).(jsonMap)
+	output, err := maasify(Client{}, original).GetMap()
+	c.Assert(err, IsNil)
 	c.Check(len(output), Equals, len(original))
 }
 
 // When maasify() converts a map, the result contains JSONObjects.
 func (suite *JSONObjectSuite) TestMaasifyMapContainsJSONObjects(c *C) {
-	mp := maasify(Client{}, map[string]interface{}{"key": "value"}).(jsonMap)
-	var entry JSONObject
-	entry = mp["key"]
-	c.Check((string)(entry.(jsonString)), Equals, "value")
+	jsonobj := maasify(Client{}, map[string]interface{}{"key": "value"})
+	mp, err := jsonobj.GetMap()
+	var _ JSONObject = mp["key"]
+	c.Assert(err, IsNil)
+	entry, err := mp["key"].GetString()
+	c.Check(entry, Equals, "value")
 }
 
 // maasify() converts MAAS objects.
@@ -65,66 +75,89 @@
 		"resource_uri": "http://example.com/foo",
 		"size":         "3",
 	}
-	output := maasify(Client{}, original).(jsonMAASObject)
-	c.Check(len(output.jsonMap), Equals, len(original))
-	c.Check((string)(output.jsonMap["size"].(jsonString)), Equals, "3")
+	obj, err := maasify(Client{}, original).GetMAASObject()
+	c.Assert(err, IsNil)
+	c.Check(len(obj.GetMap()), Equals, len(original))
+	size, err := obj.GetMap()["size"].GetString()
+	c.Assert(err, IsNil)
+	c.Check(size, Equals, "3")
 }
 
 // maasify() passes its client to a MAASObject it creates.
-func (suite *JSONObjectSuite) TestMaasifyPassesInfoToMAASObject(c *C) {
+func (suite *JSONObjectSuite) TestMaasifyPassesClientToMAASObject(c *C) {
 	client := Client{}
 	original := map[string]interface{}{"resource_uri": "/foo"}
-	output := maasify(client, original).(jsonMAASObject)
+	output, err := maasify(client, original).GetMAASObject()
+	c.Assert(err, IsNil)
 	c.Check(output.client, Equals, client)
 }
 
 // maasify() passes its client into an array of MAASObjects it creates.
-func (suite *JSONObjectSuite) TestMaasifyPassesInfoIntoArray(c *C) {
+func (suite *JSONObjectSuite) TestMaasifyPassesClientIntoArray(c *C) {
 	client := Client{}
 	obj := map[string]interface{}{"resource_uri": "/foo"}
 	list := []interface{}{obj}
-	output := maasify(client, list).(jsonArray)
-	c.Check(output[0].(jsonMAASObject).client, Equals, client)
+	jsonobj, err := maasify(client, list).GetArray()
+	c.Assert(err, IsNil)
+	out, err := jsonobj[0].GetMAASObject()
+	c.Assert(err, IsNil)
+	c.Check(out.client, Equals, client)
 }
 
 // maasify() passes its client into a map of MAASObjects it creates.
-func (suite *JSONObjectSuite) TestMaasifyPassesInfoIntoMap(c *C) {
+func (suite *JSONObjectSuite) TestMaasifyPassesClientIntoMap(c *C) {
 	client := Client{}
 	obj := map[string]interface{}{"resource_uri": "/foo"}
 	mp := map[string]interface{}{"key": obj}
-	output := maasify(client, mp).(jsonMap)
-	c.Check(output["key"].(jsonMAASObject).client, Equals, client)
+	jsonobj, err := maasify(client, mp).GetMap()
+	c.Assert(err, IsNil)
+	out, err := jsonobj["key"].GetMAASObject()
+	c.Assert(err, IsNil)
+	c.Check(out.client, Equals, client)
 }
 
 // maasify() passes its client all the way down into any MAASObjects in the
 // object structure it creates.
-func (suite *JSONObjectSuite) TestMaasifyPassesInfoAllTheWay(c *C) {
+func (suite *JSONObjectSuite) TestMaasifyPassesClientAllTheWay(c *C) {
 	client := Client{}
 	obj := map[string]interface{}{"resource_uri": "/foo"}
 	mp := map[string]interface{}{"key": obj}
 	list := []interface{}{mp}
-	output := maasify(client, list).(jsonArray)
-	maasobj := output[0].(jsonMap)["key"]
-	c.Check(maasobj.(jsonMAASObject).client, Equals, client)
+	jsonobj, err := maasify(client, list).GetArray()
+	c.Assert(err, IsNil)
+	outerMap, err := jsonobj[0].GetMap()
+	c.Assert(err, IsNil)
+	out, err := outerMap["key"].GetMAASObject()
+	c.Assert(err, IsNil)
+	c.Check(out.client, Equals, client)
 }
 
 // maasify() converts Booleans.
 func (suite *JSONObjectSuite) TestMaasifyConvertsBool(c *C) {
-	c.Check(bool(maasify(Client{}, true).(jsonBool)), Equals, true)
-	c.Check(bool(maasify(Client{}, false).(jsonBool)), Equals, false)
+	t, err := maasify(Client{}, true).GetBool()
+	c.Assert(err, IsNil)
+	f, err := maasify(Client{}, false).GetBool()
+	c.Assert(err, IsNil)
+	c.Check(t, Equals, true)
+	c.Check(f, Equals, false)
 }
 
 // Parse takes you from a JSON blob to a JSONObject.
 func (suite *JSONObjectSuite) TestParseMaasifiesJSONBlob(c *C) {
 	blob := []byte("[12]")
 	obj, err := Parse(Client{}, blob)
-	c.Check(err, IsNil)
-	c.Check(float64(obj.(jsonArray)[0].(jsonFloat64)), Equals, 12.0)
+	c.Assert(err, IsNil)
+
+	arr, err := obj.GetArray()
+	c.Assert(err, IsNil)
+	out, err := arr[0].GetFloat64()
+	c.Assert(err, IsNil)
+	c.Check(out, Equals, 12.0)
 }
 
 // String-type JSONObjects convert only to string.
 func (suite *JSONObjectSuite) TestConversionsString(c *C) {
-	obj := jsonString("Test string")
+	obj := maasify(Client{}, "Test string")
 
 	value, err := obj.GetString()
 	c.Check(err, IsNil)
@@ -144,7 +177,7 @@
 
 // Number-type JSONObjects convert only to float64.
 func (suite *JSONObjectSuite) TestConversionsFloat64(c *C) {
-	obj := jsonFloat64(1.1)
+	obj := maasify(Client{}, 1.1)
 
 	value, err := obj.GetFloat64()
 	c.Check(err, IsNil)
@@ -164,8 +197,7 @@
 
 // Map-type JSONObjects convert only to map.
 func (suite *JSONObjectSuite) TestConversionsMap(c *C) {
-	input := map[string]JSONObject{"x": jsonString("y")}
-	obj := jsonMap(input)
+	obj := maasify(Client{}, map[string]interface{}{"x": "y"})
 
 	value, err := obj.GetMap()
 	c.Check(err, IsNil)
@@ -187,7 +219,7 @@
 
 // Array-type JSONObjects convert only to array.
 func (suite *JSONObjectSuite) TestConversionsArray(c *C) {
-	obj := jsonArray([]JSONObject{jsonString("item")})
+	obj := maasify(Client{}, []interface{}{"item"})
 
 	value, err := obj.GetArray()
 	c.Check(err, IsNil)
@@ -209,7 +241,7 @@
 
 // Boolean-type JSONObjects convert only to bool.
 func (suite *JSONObjectSuite) TestConversionsBool(c *C) {
-	obj := jsonBool(false)
+	obj := maasify(Client{}, false)
 
 	value, err := obj.GetBool()
 	c.Check(err, IsNil)

=== modified file 'maas.go'
--- maas.go	2013-02-05 11:35:09 +0000
+++ maas.go	2013-02-12 05:49:22 +0000
@@ -5,6 +5,6 @@
 
 // NewMAAS returns an interface to the MAAS API as a MAASObject.
 func NewMAAS(client Client) MAASObject {
-	input := map[string]JSONObject{resourceURI: jsonString(client.BaseURL.String())}
-	return newJSONMAASObject(jsonMap(input), client)
+	attrs := map[string]interface{}{resourceURI: client.BaseURL.String()}
+	return newJSONMAASObject(attrs, client)
 }

=== modified file 'maasobject.go'
--- maasobject.go	2013-02-07 16:01:48 +0000
+++ maasobject.go	2013-02-12 05:49:22 +0000
@@ -5,88 +5,77 @@
 
 import (
 	"errors"
+	"fmt"
 	"net/url"
 )
 
 // MAASObject represents a MAAS object as returned by the MAAS API, such as a
 // Node or a Tag.
-// This is a special kind of JSONObject.  A MAAS API call will usually return
-// either a MAASObject or a list of MAASObjects.  (The list itself will be
-// wrapped in a JSONObject).
-type MAASObject interface {
-	JSONObject
-
-	// Utility method to extract a string field from this MAAS object.
-	GetField(name string) (string, error)
-	// URL for this MAAS object.
-	URL() *url.URL
-	// Resource URI for this MAAS object.
-	URI() *url.URL
-	// Retrieve the MAAS object located at thisObject.URI()+name.
-	GetSubObject(name string) MAASObject
-	// Retrieve this MAAS object.
-	Get() (MAASObject, error)
-	// Write this MAAS object.
-	Post(params url.Values) (JSONObject, error)
-	// Update this MAAS object with the given values.
-	Update(params url.Values) (MAASObject, error)
-	// Delete this MAAS object.
-	Delete() error
-	// Invoke a GET-based method on this MAAS object.
-	CallGet(operation string, params url.Values) (JSONObject, error)
-	// Invoke a POST-based method on this MAAS object.
-	CallPost(operation string, params url.Values) (JSONObject, error)
-}
-
-// JSONObject implementation for a MAAS object.  From a decoding perspective,
-// a jsonMAASObject is just like a jsonMap except it contains a key
-// "resource_uri", and it keeps track of the Client you got it from so that
-// you can invoke API methods directly on their MAAS objects.
-// jsonMAASObject implements both JSONObject and MAASObject.
-type jsonMAASObject struct {
-	jsonMap
+// You can extract a MAASObject out of a JSONObject using
+// JSONObject.GetMAASObject.  A MAAS API call will usually return either a
+// MAASObject or a list of MAASObjects.  The list itself would be wrapped in
+// a JSONObject, so if an API call returns a list of objects "l," you first
+// obtain the array using l.GetArray().  Then, for each item "i" in the array,
+// obtain the matching MAASObject using i.GetMAASObject().
+type MAASObject struct {
+	values map[string]JSONObject
 	client Client
 	uri    *url.URL
 }
 
 // newJSONMAASObject creates a new MAAS object.  It will panic if the given map
 // does not contain a valid URL for the 'resource_uri' key.
-func newJSONMAASObject(jmap jsonMap, client Client) jsonMAASObject {
-	const panicPrefix = "Error processing MAAS object: "
-	uriObj, ok := jmap[resourceURI]
+func newJSONMAASObject(jmap map[string]interface{}, client Client) MAASObject {
+	obj, err := maasify(client, jmap).GetMAASObject()
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+var noResourceURI = errors.New("not a MAAS object: no 'resource_uri' key")
+
+// extractURI obtains the "resource_uri" string from a JSONObject map.
+func extractURI(attrs map[string]JSONObject) (*url.URL, error) {
+	uriEntry, ok := attrs[resourceURI]
 	if !ok {
-		panic(errors.New(panicPrefix + "no 'resource_uri' key present in the given jsonMap."))
-	}
-	uriString, err := uriObj.GetString()
-	if err != nil {
-		panic(errors.New(panicPrefix + "the value of 'resource_uri' is not a string."))
-	}
-	uri, err := url.Parse(uriString)
-	if err != nil {
-		panic(errors.New(panicPrefix + "the value of 'resource_uri' is not a valid URL."))
-	}
-	return jsonMAASObject{jmap, client, uri}
-}
-
-var _ JSONObject = (*jsonMAASObject)(nil)
-var _ MAASObject = (*jsonMAASObject)(nil)
-
-// JSONObject implementation for jsonMAASObject.
-func (jsonMAASObject) Type() string                               { return "maasobject" }
-func (obj jsonMAASObject) GetString() (string, error)             { return failString(obj) }
-func (obj jsonMAASObject) GetFloat64() (float64, error)           { return failFloat64(obj) }
-func (obj jsonMAASObject) GetMap() (map[string]JSONObject, error) { return obj.jsonMap.GetMap() }
-func (obj jsonMAASObject) GetMAASObject() (MAASObject, error)     { return obj, nil }
-func (obj jsonMAASObject) GetArray() ([]JSONObject, error)        { return failArray(obj) }
-func (obj jsonMAASObject) GetBool() (bool, error)                 { return failBool(obj) }
-
-// MAASObject implementation for jsonMAASObject.
-
-func (obj jsonMAASObject) GetField(name string) (string, error) {
-	return obj.jsonMap[name].GetString()
-}
-
-func (obj jsonMAASObject) URI() *url.URL {
+		return nil, noResourceURI
+	}
+	uri, err := uriEntry.GetString()
+	if err != nil {
+		return nil, fmt.Errorf("invalid resource_uri: %v", uri)
+	}
+	resourceURL, err := url.Parse(uri)
+	if err != nil {
+		return nil, fmt.Errorf("resource_uri does not contain a valid URL: %v", uri)
+	}
+	return resourceURL, nil
+}
+
+// JSONObject getter for a MAAS object.  From a decoding perspective, a
+// MAASObject is just like a map except it contains a key "resource_uri", and
+// it keeps track of the Client you got it from so that you can invoke API
+// methods directly on their MAAS objects.
+func (obj JSONObject) GetMAASObject() (MAASObject, error) {
+	attrs, err := obj.GetMap()
+	if err != nil {
+		return MAASObject{}, err
+	}
+	uri, err := extractURI(attrs)
+	if err != nil {
+		return MAASObject{}, err
+	}
+	return MAASObject{values: attrs, client: obj.client, uri: uri}, nil
+}
+
+// GetField extracts a string field from this MAAS object.
+func (obj MAASObject) GetField(name string) (string, error) {
+	return obj.values[name].GetString()
+}
+
+// URI is the resource URI for this MAAS object.  It is an absolute path, but
+// without a network part.
+func (obj MAASObject) URI() *url.URL {
 	// Duplicate the URL.
 	uri, err := url.Parse(obj.uri.String())
 	if err != nil {
@@ -95,11 +84,20 @@
 	return uri
 }
 
-func (obj jsonMAASObject) URL() *url.URL {
+// URL returns a full absolute URL (including network part) for this MAAS
+// object on the API.
+func (obj MAASObject) URL() *url.URL {
 	return obj.client.GetURL(obj.URI())
 }
 
-func (obj jsonMAASObject) GetSubObject(name string) MAASObject {
+// GetMap returns all of the object's attributes in the form of a map.
+func (obj MAASObject) GetMap() map[string]JSONObject {
+	return obj.values
+}
+
+// GetSubObject returns a new MAASObject representing the API resource found
+// at a given sub-path of the current object's resource URI.
+func (obj MAASObject) GetSubObject(name string) MAASObject {
 	uri := obj.URI()
 	newUrl, err := url.Parse(name)
 	if err != nil {
@@ -107,66 +105,74 @@
 	}
 	resUrl := uri.ResolveReference(newUrl)
 	resUrl.Path = EnsureTrailingSlash(resUrl.Path)
-	input := map[string]JSONObject{resourceURI: jsonString(resUrl.String())}
-	return newJSONMAASObject(jsonMap(input), obj.client)
+	input := map[string]interface{}{resourceURI: resUrl.String()}
+	return newJSONMAASObject(input, obj.client)
 }
 
 var NotImplemented = errors.New("Not implemented")
 
-func (obj jsonMAASObject) Get() (MAASObject, error) {
+// Get retrieves a fresh copy of this MAAS object from the API.
+func (obj MAASObject) Get() (MAASObject, error) {
 	uri := obj.URI()
 	result, err := obj.client.Get(uri, "", url.Values{})
 	if err != nil {
-		return nil, err
+		return MAASObject{}, err
 	}
 	jsonObj, err := Parse(obj.client, result)
 	if err != nil {
-		return nil, err
+		return MAASObject{}, err
 	}
 	return jsonObj.GetMAASObject()
 }
 
-func (obj jsonMAASObject) Post(params url.Values) (JSONObject, error) {
+// Post overwrites this object's existing value on the API with those given
+// in "params."  It returns the object's new value as received from the API.
+func (obj MAASObject) Post(params url.Values) (JSONObject, error) {
 	uri := obj.URI()
 	result, err := obj.client.Post(uri, "", params)
 	if err != nil {
-		return nil, err
+		return JSONObject{}, err
 	}
 	return Parse(obj.client, result)
 }
 
-func (obj jsonMAASObject) Update(params url.Values) (MAASObject, error) {
+// Update modifies this object on the API, based on the values given in
+// "params."  It returns the object's new value as received from the API.
+func (obj MAASObject) Update(params url.Values) (MAASObject, error) {
 	uri := obj.URI()
 	result, err := obj.client.Put(uri, params)
 	if err != nil {
-		return nil, err
+		return MAASObject{}, err
 	}
 	jsonObj, err := Parse(obj.client, result)
 	if err != nil {
-		return nil, err
+		return MAASObject{}, err
 	}
 	return jsonObj.GetMAASObject()
 }
 
-func (obj jsonMAASObject) Delete() error {
+// Delete removes this object on the API.
+func (obj MAASObject) Delete() error {
 	uri := obj.URI()
 	return obj.client.Delete(uri)
 }
 
-func (obj jsonMAASObject) CallGet(operation string, params url.Values) (JSONObject, error) {
+// CallGet invokes an idempotent API method on this object.
+func (obj MAASObject) CallGet(operation string, params url.Values) (JSONObject, error) {
 	uri := obj.URI()
 	result, err := obj.client.Get(uri, operation, params)
 	if err != nil {
-		return nil, err
+		return JSONObject{}, err
 	}
 	return Parse(obj.client, result)
 }
 
-func (obj jsonMAASObject) CallPost(operation string, params url.Values) (JSONObject, error) {
+// CallPost invokes a non-idempotent API method on this object.
+func (obj MAASObject) CallPost(operation string, params url.Values) (JSONObject, error) {
 	uri := obj.URI()
 	result, err := obj.client.Post(uri, operation, params)
 	if err != nil {
-		return nil, err
+		return JSONObject{}, err
 	}
 	return Parse(obj.client, result)
 }

=== modified file 'maasobject_test.go'
--- maasobject_test.go	2013-02-07 16:01:48 +0000
+++ maasobject_test.go	2013-02-12 05:49:22 +0000
@@ -18,16 +18,10 @@
 	return "http://example.com/" + fmt.Sprint(rand.Int31())
 }
 
-func makeFakeMAASObject() jsonMAASObject {
-	attrs := make(map[string]JSONObject)
-	attrs[resourceURI] = jsonString(makeFakeResourceURI())
-	return jsonMAASObject{jsonMap: jsonMap(attrs)}
-}
-
-// jsonMAASObjects convert only to map or to MAASObject.
+// JSONObjects containing MAAS objects convert only to map or to MAASObject.
 func (suite *MAASObjectSuite) TestConversionsMAASObject(c *C) {
-	input := map[string]JSONObject{resourceURI: jsonString("someplace")}
-	obj := jsonMAASObject{jsonMap: jsonMap(input)}
+	input := map[string]interface{}{resourceURI: "someplace"}
+	obj := maasify(Client{}, input)
 
 	mp, err := obj.GetMap()
 	c.Check(err, IsNil)
@@ -35,9 +29,10 @@
 	c.Check(err, IsNil)
 	c.Check(text, Equals, "someplace")
 
-	maasobj, err := obj.GetMAASObject()
-	c.Check(err, IsNil)
-	_ = maasobj.(jsonMAASObject)
+	var maasobj MAASObject
+	maasobj, err = obj.GetMAASObject()
+	c.Assert(err, IsNil)
+	c.Check(maasobj, NotNil)
 
 	_, err = obj.GetString()
 	c.Check(err, NotNil)
@@ -56,8 +51,9 @@
 		msg := recoveredError.(error).Error()
 		c.Check(msg, Matches, ".*no 'resource_uri' key.*")
 	}()
-	input := map[string]JSONObject{"test": jsonString("test")}
-	newJSONMAASObject(jsonMap(input), Client{})
+
+	input := map[string]interface{}{"test": "test"}
+	newJSONMAASObject(input, Client{})
 }
 
 func (suite *MAASObjectSuite) TestNewJSONMAASObjectPanicsIfResourceURINotString(c *C) {
@@ -65,10 +61,11 @@
 		recoveredError := recover()
 		c.Check(recoveredError, NotNil)
 		msg := recoveredError.(error).Error()
-		c.Check(msg, Matches, ".*the value of 'resource_uri' is not a string.*")
+		c.Check(msg, Matches, ".*invalid resource_uri.*")
 	}()
-	input := map[string]JSONObject{resourceURI: jsonFloat64(77.7)}
-	newJSONMAASObject(jsonMap(input), Client{})
+
+	input := map[string]interface{}{resourceURI: 77.77}
+	newJSONMAASObject(input, Client{})
 }
 
 func (suite *MAASObjectSuite) TestNewJSONMAASObjectPanicsIfResourceURINotURL(c *C) {
@@ -76,16 +73,17 @@
 		recoveredError := recover()
 		c.Check(recoveredError, NotNil)
 		msg := recoveredError.(error).Error()
-		c.Check(msg, Matches, ".*the value of 'resource_uri' is not a valid URL.*")
+		c.Check(msg, Matches, ".*resource_uri.*valid URL.*")
 	}()
-	input := map[string]JSONObject{resourceURI: jsonString("")}
-	newJSONMAASObject(jsonMap(input), Client{})
+
+	input := map[string]interface{}{resourceURI: ""}
+	newJSONMAASObject(input, Client{})
 }
 
 func (suite *MAASObjectSuite) TestNewJSONMAASObjectSetsUpURI(c *C) {
 	URI, _ := url.Parse("http://example.com/a/resource")
-	input := map[string]JSONObject{resourceURI: jsonString(URI.String())}
-	obj := newJSONMAASObject(jsonMap(input), Client{})
+	attrs := map[string]interface{}{resourceURI: URI.String()}
+	obj := newJSONMAASObject(attrs, Client{})
 	c.Check(obj.uri, DeepEquals, URI)
 }
 
@@ -93,9 +91,9 @@
 	baseURL, _ := url.Parse("http://example.com/")
 	uri := "http://example.com/a/resource"
 	resourceURL, _ := url.Parse(uri)
-	input := map[string]JSONObject{resourceURI: jsonString(uri)}
+	input := map[string]interface{}{resourceURI: uri}
 	client := Client{BaseURL: baseURL}
-	obj := newJSONMAASObject(jsonMap(input), client)
+	obj := newJSONMAASObject(input, client)
 
 	URL := obj.URL()
 
@@ -105,9 +103,9 @@
 func (suite *MAASObjectSuite) TestGetSubObjectRelative(c *C) {
 	baseURL, _ := url.Parse("http://example.com/")
 	uri := "http://example.com/a/resource/"
-	input := map[string]JSONObject{resourceURI: jsonString(uri)}
+	input := map[string]interface{}{resourceURI: uri}
 	client := Client{BaseURL: baseURL}
-	obj := newJSONMAASObject(jsonMap(input), client)
+	obj := newJSONMAASObject(input, client)
 	subName := "test"
 
 	subObj := obj.GetSubObject(subName)
@@ -122,9 +120,9 @@
 func (suite *MAASObjectSuite) TestGetSubObjectAbsolute(c *C) {
 	baseURL, _ := url.Parse("http://example.com/")
 	uri := "http://example.com/a/resource/"
-	input := map[string]JSONObject{resourceURI: jsonString(uri)}
+	input := map[string]interface{}{resourceURI: uri}
 	client := Client{BaseURL: baseURL}
-	obj := newJSONMAASObject(jsonMap(input), client)
+	obj := newJSONMAASObject(input, client)
 	subName := "/b/test"
 
 	subObj := obj.GetSubObject(subName)
@@ -138,10 +136,10 @@
 	uri := "http://example.com/a/resource"
 	fieldName := "field name"
 	fieldValue := "a value"
-	input := map[string]JSONObject{
-		resourceURI: jsonString(uri), fieldName: jsonString(fieldValue),
+	input := map[string]interface{}{
+		resourceURI: uri, fieldName: fieldValue,
 	}
-	obj := jsonMAASObject{jsonMap: jsonMap(input)}
+	obj := newJSONMAASObject(input, Client{})
 	value, err := obj.GetField(fieldName)
 	c.Check(err, IsNil)
 	c.Check(value, Equals, fieldValue)

=== modified file 'testservice.go'
--- testservice.go	2013-02-07 10:01:10 +0000
+++ testservice.go	2013-02-12 05:49:22 +0000
@@ -21,9 +21,6 @@
 	TestServer *TestServer
 }
 
-// TestMAASObject implements the MAASObject interface.
-var _ MAASObject = (*TestMAASObject)(nil)
-
 // NewTestMAAS returns a TestMAASObject that implements the MAASObject
 // interface and thus can be used as a test object instead of the one returned
 // by gomaasapi.NewMAAS().
@@ -84,28 +81,21 @@
 // string representing a map and contain a string value for the key 
 // 'system_id'.  e.g. `{"system_id": "mysystemid"}`.
 // If one of these conditions is not met, NewNode panics.
-func (server *TestServer) NewNode(json string) MAASObject {
-	obj, err := Parse(server.client, []byte(json))
-	if err != nil {
-		panic(err)
-	}
-	mapobj, err := obj.GetMap()
-	if err != nil {
-		panic(err)
-	}
-	systemId, hasSystemId := mapobj["system_id"]
+func (server *TestServer) NewNode(jsonText string) MAASObject {
+	var attrs map[string]interface{}
+	err := json.Unmarshal([]byte(jsonText), &attrs)
+	if err != nil {
+		panic(err)
+	}
+	systemIdEntry, hasSystemId := attrs["system_id"]
 	if !hasSystemId {
 		panic("The given map json string does not contain a 'system_id' value.")
 	}
-	stringSystemId, err := systemId.GetString()
-	if err != nil {
-		panic(err)
-	}
-	resourceUri := getNodeURI(server.version, stringSystemId)
-	mapobj[resourceURI] = jsonString(resourceUri)
-	maasobj := newJSONMAASObject(mapobj, server.client)
-	server.nodes[stringSystemId] = maasobj
-	return maasobj
+	systemId := systemIdEntry.(string)
+	attrs[resourceURI] = getNodeURI(server.version, systemId)
+	obj := newJSONMAASObject(attrs, server.client)
+	server.nodes[systemId] = obj
+	return obj
 }
 
 // Returns a map associating all the nodes' system ids with the nodes'
@@ -129,8 +119,7 @@
 	if !found {
 		panic("No node with such 'system_id'.")
 	}
-	mapObj, _ := node.GetMap()
-	mapObj[key] = jsonString(value)
+	node.GetMap()[key] = maasify(server.client, value)
 }
 
 func getNodeListingURL(version string) string {
@@ -191,9 +180,27 @@
 	}
 }
 
+// MarshalJSON tells the standard json package how to serialize a JSONObject.
+func (obj JSONObject) MarshalJSON() ([]byte, error) {
+	if obj.IsNil() {
+		return json.Marshal(nil)
+	}
+	return json.Marshal(obj.value)
+}
+
+// With MarshalJSON, JSONObject implements json.Marshaler.
+var _ json.Marshaler = (*JSONObject)(nil)
+
+// MarshalJSON tells the standard json package how to serialize a MAASObject.
+func (obj MAASObject) MarshalJSON() ([]byte, error) {
+	return json.Marshal(obj.GetMap())
+}
+
+// With MarshalJSON, MAASObject implements json.Marshaler.
+var _ json.Marshaler = (*MAASObject)(nil)
+
 func marshalNode(node MAASObject) string {
-	mapObj, _ := node.GetMap()
-	res, _ := json.Marshal(mapObj)
+	res, _ := json.Marshal(node)
 	return string(res)
 
 }
@@ -253,8 +260,7 @@
 	var convertedNodes = []map[string]JSONObject{}
 	for systemId, node := range server.nodes {
 		if !hasId || contains(ids, systemId) {
-			mapp, _ := node.GetMap()
-			convertedNodes = append(convertedNodes, mapp)
+			convertedNodes = append(convertedNodes, node.GetMap())
 		}
 	}
 	res, _ := json.Marshal(convertedNodes)

=== modified file 'testservice_test.go'
--- testservice_test.go	2013-02-07 10:01:10 +0000
+++ testservice_test.go	2013-02-12 05:49:22 +0000
@@ -78,8 +78,8 @@
 	suite.server.ChangeNode("mysystemid", "newfield", "newvalue")
 
 	node, _ := suite.server.nodes["mysystemid"]
-	mapObj, _ := node.GetMap()
-	field, _ := mapObj["newfield"].GetString()
+	field, err := node.GetField("newfield")
+	c.Assert(err, IsNil)
 	c.Check(field, Equals, "newvalue")
 }
 
@@ -234,13 +234,16 @@
 
 	c.Check(err, IsNil)
 	listNodes, err := listNodeObjects.GetArray()
-	c.Check(err, IsNil)
+	c.Assert(err, IsNil)
 	c.Check(len(listNodes), Equals, 1)
-	node, _ := listNodes[0].GetMAASObject()
-	systemId, _ := node.GetField("system_id")
+	node, err := listNodes[0].GetMAASObject()
+	c.Assert(err, IsNil)
+	systemId, err := node.GetField("system_id")
+	c.Assert(err, IsNil)
 	c.Check(systemId, Equals, "mysystemid")
 	resourceURI, _ := node.GetField(resourceURI)
-	expectedResourceURI := fmt.Sprintf("/api/%s/nodes/mysystemid/", suite.TestMAASObject.TestServer.version)
+	apiVersion := suite.TestMAASObject.TestServer.version
+	expectedResourceURI := fmt.Sprintf("/api/%s/nodes/mysystemid/", apiVersion)
 	c.Check(resourceURI, Equals, expectedResourceURI)
 }