Merge lp:~gz/gomaasapi/gomaasapi into lp:~gophers/gomaasapi/initial_for_review

[Martin Packman]

Rollup of all relevent changes on lp:gomaasapi

This is for review only, showing the current trunk of the project in
the diff (from the initial commit of the licence and a couple of stub
go files). Note it's not possible for the Red squad to update this
proposal directly, so don't expect code changes in response to comments
to appear here, please watch for other merge proposals. :)

https://codereview.appspot.com/7228069/

[Martin Packman (gz)]

Reviewers: mp+145811_code.launchpad.net,

Message:
Please take a look.

Description:
Rollup of all relevent changes on lp:gomaasapi

This is for review only, showing the current trunk of the project in
the diff (from the initial commit of the licence and a couple of stub
go files). Note it's not possible for the Red squad to update this
proposal directly, so don't expect code changes in response to comments
to appear here, please watch for other merge proposals. :)

https://code.launchpad.net/~gz/gomaasapi/gomaasapi/+merge/145811

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/7228069/

Affected files:
   A README
   A [revision details]
   A client.go
   A client_test.go
   A example/live_example.go
   M gomaasapi.go
   M gomaasapi_test.go
   A jsonobject.go
   A jsonobject_test.go
   A maas.go
   A maas_test.go
   A maasobject.go
   A maasobject_test.go
   A oauth.go
   A templates/source.go
   A templates/source_test.go
   A testing.go
   A util.go
   A util_test.go

[Roger Peppe (rogpeppe)]

seems like a good start.

lots of minor comments, but one or two more significant queries. in
particular, it looks like it's only possible to use the maas package if
you know exactly how maas works. i'd like to see all the gruesome http
details hidden behind an API that actually reflects the operations and
entities that maas provides.

i'm +1 on TheMue's comment on JSONObject. it seems like it's a lot of
code that doesn't solve any real problem.

https://codereview.appspot.com/7228069/diff/1/client.go
File client.go (right):

https://codereview.appspot.com/7228069/diff/1/client.go#newcode15
client.go:15: type Client struct {
On 2013/02/01 10:43:41, TheMue wrote:
> Please add godoc documentation on all public types and functions.

+1
also please unexport any methods that aren't essential to using the
package.

https://codereview.appspot.com/7228069/diff/1/client.go#newcode21
client.go:21: operationParamName = "op"
this seems a very long name for a very short string :-)

https://codereview.appspot.com/7228069/diff/1/client.go#newcode24
client.go:24: func (client Client) dispatchRequest(request
*http.Request) ([]byte, error) {
On 2013/02/01 10:43:41, TheMue wrote:
> Here (c Client) is more usual.

further to that, i'd suggest that on type with side effects, it's
conventional to use pointer types, so you'd use *Client throughout.

https://codereview.appspot.com/7228069/diff/1/client.go#newcode26
client.go:26: httpClient := http.Client{}
unless there's a specific reason not to, it would be more conventional
to use http.DefaultClient here rather than creating a new instance of
http.Client. that way connections can be reused.

https://codereview.appspot.com/7228069/diff/1/client.go#newcode36
client.go:36: return body, errors.New("Error requesting the MAAS server:
" + response.Status + ".")
On 2013/02/01 10:43:41, TheMue wrote:
> return nil, fmt.Errorf("gomaasapi: cannot dispatch request: %v",
> response.Status)

> In case of an error no value is returned.

+1

but we wouldn't usually include the package name in the error message
although the Go core would. either is acceptable.

https://codereview.appspot.com/7228069/diff/1/client.go#newcode54
client.go:54: queryUrl := client.GetURL(URI)
the distinction between "URI" and "URL" is unclear to me here. perhaps
some documentation might make things more clear?

also, we tend to use lower case names for variables, so "uri" rather
than "URI".

https://codereview.appspot.com/7228069/diff/1/client.go#newcode66
client.go:66: request, err := http.NewRequest(method, URL.String(),
strings.NewReader(string(parameters.Encode())))
the string conversion on the result of Encode is unnecessary here.

https://codereview.appspot.com/7228069/diff/1/client.go#newcode90
client.go:90: _, err2 := client.dispatchRequest(request)
s/err2/err/
no real need to make another variable.

https://codereview.appspot.com/7228069/diff/1/client.go#newcode104
client.go:104: var _ OAuthSigner = (*anonSigner)(nil)
given that you're using a by-value method above, this may as well be:

var _ OAuthSigner = anonSigner{}

https://codereview.appspot.com/7228069/diff/1/client.go#newcode121
client.go:121: errString := "Invalid API key. The format ...

[lp:~gz/gomaasapi/gomaasapi]

13. By Raphaël Badin on 2013-02-04

[r=jtv][bug=][author=rvb] Add testservice that can be used to write tests for libraries using gomaasapi.

[William Reade (fwereade)]

+1s to just about everything rog and frank said, and a few comments on
JSONObject:

https://codereview.appspot.com/7228069/diff/1/jsonobject.go
File jsonobject.go (right):

https://codereview.appspot.com/7228069/diff/1/jsonobject.go#newcode32
jsonobject.go:32: GetString() (string, error)
On 2013/02/01 17:30:05, rog wrote:
> i don't really see what these methods have to offer over:

> s, ok := someValue.(string)

The errors are quite helpful, I think. But I don't think JSONObject
needs all these Get methods when we could have a bunch of GetFoo(obj
jsonObject) functions -- I think it's be a lot cleaner. See below.

https://codereview.appspot.com/7228069/diff/1/jsonobject.go#newcode65
jsonobject.go:65: // Internal: turn a completely untyped json.Unmarshal
result into a
It's also conventional to start doc comments with the name of the thing
being commented on; it makes it neater to use the comment as a sentence
in other contexts. I know it's academic in this case, but worth bearing
in mind in general.

https://codereview.appspot.com/7228069/diff/1/jsonobject.go#newcode119
jsonobject.go:119: return errors.New(msg)
On 2013/02/01 17:30:05, rog wrote:
> fmt.Errorf("cannot convert %#v to %s", obj, wanted_type)
+1

https://codereview.appspot.com/7228069/diff/1/jsonobject.go#newcode159
jsonobject.go:159: func (obj jsonString) GetBool() (bool, error)
         { return failBool(obj) }
This bit is awfully dense and repetitive. I think a few standalone Get*
funcs would work a bit better here, as mentioned above:

func (jsonString) Type() string { return "string" }
func (jsonFloat64) Type() string { return "float64" }
...

func GetString(obj JSONObject) (string, error) {
     if obj.Type() == "string" {
         return string(obj), nil
     }
     return "", failConversion("string", obj)
}

func GetFloat64(obj JSONObject) (float64, error) {
     if obj.Type() == "float64" {
         return float64(obj), nil
     }
     return "", failConversion("float64", obj)
}

...

https://codereview.appspot.com/7228069/diff/1/maasobject.go
File maasobject.go (right):

https://codereview.appspot.com/7228069/diff/1/maasobject.go#newcode57
maasobject.go:57: panic("Cannot create jsonMAASObject object, no
'resource_uri' key present in the given jsonMap.")
Conventional to panic with errors

https://codereview.appspot.com/7228069/

[Roger Peppe (rogpeppe)]

https://codereview.appspot.com/7228069/diff/1/jsonobject.go
File jsonobject.go (right):

https://codereview.appspot.com/7228069/diff/1/jsonobject.go#newcode159
jsonobject.go:159: func (obj jsonString) GetBool() (bool, error)
         { return failBool(obj) }
On 2013/02/05 12:26:31, fwereade wrote:
> This bit is awfully dense and repetitive. I think a few standalone
Get* funcs
> would work a bit better here, as mentioned above:

> func (jsonString) Type() string { return "string" }
> func (jsonFloat64) Type() string { return "float64" }
> ...

> func GetString(obj JSONObject) (string, error) {
> if obj.Type() == "string" {
> return string(obj), nil
> }
> return "", failConversion("string", obj)
> }

> func GetFloat64(obj JSONObject) (float64, error) {
> if obj.Type() == "float64" {
> return float64(obj), nil
> }
> return "", failConversion("float64", obj)
> }

> ...

if that's the case, why bother with the JSONObject type at all?
why not:

func GetString(obj interface{}) (string, error) {
     if s, ok := obj.(string); ok {
         return s, nil
     }
     return "", failConversion("string", obj)
}

or even a single function:

// Get sets the value of into (which must be a pointer
// to one of float64, string, map[string]interface{},
// bool or MaasObject) to the value of jsonObj.
func Get(jsonObj interface{}, into interface{}) error {
     var ok bool
     switch into := into.(type) {
     case *string:
         *into, ok = jsonObj.(string)
     case *float64:
         *into, ok = jsonObj.(float64)
     etc
     }
     if !ok {
         return failConversion(reflect.TypeOf(into).Elem().String(),
jsonObj)
     }
     return nil
}

but all this seems like it's trying to do something
similar to launchpad.net/juju-core/schema without
the nice generality that that package provides.

https://codereview.appspot.com/7228069/

[lp:~gz/gomaasapi/gomaasapi]

14. By Jeroen T. Vermeulen on 2013-02-05

[r=rvb][bug=][author=jtv] Address a large number of smaller review points.

[Raphaël Badin (rvb)]

Thanks a lot for the reviews, another batch of improvements:
https://code.launchpad.net/~rvb/gomaasapi/review-changes-2/+merge/146627

https://codereview.appspot.com/7228069/

[lp:~gz/gomaasapi/gomaasapi]

15. By Raphaël Badin on 2013-02-06

[r=jtv][bug=][author=rvb] Address a large number of small review points.

[Roger Peppe (rogpeppe)]

it would be fantastic if these changes could be proposed
with lbox -cr. if that's not feasible, i'll review in the old fashioned
way, but i'd prefer to be able to comment inline.

On 6 February 2013 04:01, <email address hidden> wrote:
> And another:
> https://code.launchpad.net/~jtv/gomaasapi/review-changes-3/+merge/146768
>
> https://codereview.appspot.com/7228069/

[lp:~gz/gomaasapi/gomaasapi]

16. By Jeroen T. Vermeulen on 2013-02-06

[r=rvb][bug=][author=jtv] More of the simple review changes from https://codereview.appspot.com/7228069/

[Martin Packman (gz)]

Please take a look.

https://codereview.appspot.com/7228069/

=== added file 'README'
--- README	1970-01-01 00:00:00 +0000
+++ README	2013-02-06 17:03:19 +0000
@@ -0,0 +1,12 @@
+.. -*- mode: rst -*-
+
+******************************
+MAAS API client library for Go
+******************************
+
+This library serves as a minimal client for communicating with the MAAS web
+API in Go programs.
+
+For more information see the `project homepage`_.
+
+.. _project homepage: https://launchpad.net/gomaasapi

=== added file 'client.go'
--- client.go	1970-01-01 00:00:00 +0000
+++ client.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,138 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// Client represents a way ot communicating with a MAAS API instance.
+// It is stateless, so it can have concurrent requests in progress.
+type Client struct {
+	BaseURL *url.URL
+	Signer  OAuthSigner
+}
+
+func (client Client) dispatchRequest(request *http.Request) ([]byte, error) {
+	client.Signer.OAuthSign(request)
+	httpClient := http.Client{}
+	response, err := httpClient.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	body, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return nil, err
+	}
+	if response.StatusCode < 200 || response.StatusCode > 299 {
+		return body, fmt.Errorf("gomaasapi: got error back from server: %v", response.Status)
+	}
+	return body, nil
+}
+
+func (client Client) GetURL(uri *url.URL) *url.URL {
+	return client.BaseURL.ResolveReference(uri)
+}
+
+func (client Client) Get(uri *url.URL, operation string, parameters url.Values) ([]byte, error) {
+	opParameter := parameters.Get("op")
+	if opParameter != "" {
+		errString := fmt.Sprintf("The parameters contain a value for '%s' which is reserved parameter.")
+		return nil, errors.New(errString)
+	}
+	if operation != "" {
+		parameters.Set("op", operation)
+	}
+	queryUrl := client.GetURL(uri)
+	queryUrl.RawQuery = parameters.Encode()
+	request, err := http.NewRequest("GET", queryUrl.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	return client.dispatchRequest(request)
+}
+
+// nonIdempotentRequest is a utility method to issue a PUT or a POST request.
+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())))
+	if err != nil {
+		return nil, err
+	}
+	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	return client.dispatchRequest(request)
+}
+
+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)
+}
+
+func (client Client) Put(uri *url.URL, parameters url.Values) ([]byte, error) {
+	return client.nonIdempotentRequest("PUT", uri, parameters)
+}
+
+func (client Client) Delete(uri *url.URL) error {
+	url := client.GetURL(uri)
+	request, err := http.NewRequest("DELETE", url.String(), strings.NewReader(""))
+	if err != nil {
+		return err
+	}
+	_, err = client.dispatchRequest(request)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type anonSigner struct{}
+
+func (signer anonSigner) OAuthSign(request *http.Request) error {
+	return nil
+}
+
+// Trick to ensure *anonSigner implements the OAuthSigner interface.
+var _ OAuthSigner = anonSigner{}
+
+// NewAnonymousClient creates a client that issues anonymous requests.
+func NewAnonymousClient(BaseURL string) (*Client, error) {
+	parsedBaseURL, err := url.Parse(BaseURL)
+	if err != nil {
+		return nil, err
+	}
+	return &Client{Signer: &anonSigner{}, BaseURL: parsedBaseURL}, nil
+}
+
+// NewAuthenticatedClient parses the given MAAS API key into the individual
+// OAuth tokens and creates an Client that will use these tokens to sign the
+// requests it issues.
+func NewAuthenticatedClient(BaseURL string, apiKey string) (*Client, error) {
+	elements := strings.Split(apiKey, ":")
+	if len(elements) != 3 {
+		errString := "invalid API key %q; expected \"<consumer secret>:<token key>:<token secret>\""
+		return nil, fmt.Errorf(errString, apiKey)
+	}
+	token := &OAuthToken{
+		ConsumerKey: elements[0],
+		// The consumer secret is the empty string in MAAS' authentication.
+		ConsumerSecret: "",
+		TokenKey:       elements[1],
+		TokenSecret:    elements[2],
+	}
+	signer, err := NewPlainTestOAuthSigner(token, "MAAS API")
+	if err != nil {
+		return nil, err
+	}
+	parsedBaseURL, err := url.Parse(BaseURL)
+	if err != nil {
+		return nil, err
+	}
+	return &Client{Signer: signer, BaseURL: parsedBaseURL}, nil
+}

=== added file 'client_test.go'
--- client_test.go	1970-01-01 00:00:00 +0000
+++ client_test.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,142 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	. "launchpad.net/gocheck"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+type ClientSuite struct{}
+
+var _ = Suite(&ClientSuite{})
+
+func (suite *ClientSuite) TestClientdispatchRequestReturnsError(c *C) {
+	URI := "/some/url/?param1=test"
+	expectedResult := "expected:result"
+	server := newSingleServingServer(URI, expectedResult, http.StatusBadRequest)
+	defer server.Close()
+	client, _ := NewAnonymousClient(server.URL)
+	request, err := http.NewRequest("GET", server.URL+URI, nil)
+
+	result, err := client.dispatchRequest(request)
+
+	c.Check(err, ErrorMatches, "gomaasapi: got error back from server: 400 Bad Request.*")
+	c.Check(string(result), Equals, expectedResult)
+}
+
+func (suite *ClientSuite) TestClientdispatchRequestSignsRequest(c *C) {
+	URI := "/some/url/?param1=test"
+	expectedResult := "expected:result"
+	server := newSingleServingServer(URI, expectedResult, http.StatusOK)
+	defer server.Close()
+	client, _ := NewAuthenticatedClient(server.URL, "the:api:key")
+	request, err := http.NewRequest("GET", server.URL+URI, nil)
+
+	result, err := client.dispatchRequest(request)
+
+	c.Check(err, IsNil)
+	c.Check(string(result), Equals, expectedResult)
+	c.Check((*server.requestHeader)["Authorization"][0], Matches, "^OAuth .*")
+}
+
+func (suite *ClientSuite) TestClientGetFormatsGetParameters(c *C) {
+	URI, _ := url.Parse("/some/url")
+	expectedResult := "expected:result"
+	params := url.Values{"test": {"123"}}
+	fullURI := URI.String() + "?test=123"
+	server := newSingleServingServer(fullURI, expectedResult, http.StatusOK)
+	defer server.Close()
+	client, _ := NewAnonymousClient(server.URL)
+
+	result, err := client.Get(URI, "", params)
+
+	c.Check(err, IsNil)
+	c.Check(string(result), Equals, expectedResult)
+}
+
+func (suite *ClientSuite) TestClientGetFormatsOperationAsGetParameter(c *C) {
+	URI, _ := url.Parse("/some/url")
+	expectedResult := "expected:result"
+	fullURI := URI.String() + "?op=list"
+	server := newSingleServingServer(fullURI, expectedResult, http.StatusOK)
+	defer server.Close()
+	client, _ := NewAnonymousClient(server.URL)
+
+	result, err := client.Get(URI, "list", url.Values{})
+
+	c.Check(err, IsNil)
+	c.Check(string(result), Equals, expectedResult)
+}
+
+func (suite *ClientSuite) TestClientPostSendsRequest(c *C) {
+	URI, _ := url.Parse("/some/url")
+	expectedResult := "expected:result"
+	fullURI := URI.String() + "?op=list"
+	params := url.Values{"test": {"123"}}
+	server := newSingleServingServer(fullURI, expectedResult, http.StatusOK)
+	defer server.Close()
+	client, _ := NewAnonymousClient(server.URL)
+
+	result, err := client.Post(URI, "list", params)
+
+	c.Check(err, IsNil)
+	c.Check(string(result), Equals, expectedResult)
+	c.Check(*server.requestContent, Equals, "test=123")
+}
+
+func (suite *ClientSuite) TestClientPutSendsRequest(c *C) {
+	URI, _ := url.Parse("/some/url")
+	expectedResult := "expected:result"
+	params := url.Values{"test": {"123"}}
+	server := newSingleServingServer(URI.String(), expectedResult, http.StatusOK)
+	defer server.Close()
+	client, _ := NewAnonymousClient(server.URL)
+
+	result, err := client.Put(URI, params)
+
+	c.Check(err, IsNil)
+	c.Check(string(result), Equals, expectedResult)
+	c.Check(*server.requestContent, Equals, "test=123")
+}
+
+func (suite *ClientSuite) TestClientDeleteSendsRequest(c *C) {
+	URI, _ := url.Parse("/some/url")
+	expectedResult := "expected:result"
+	server := newSingleServingServer(URI.String(), expectedResult, http.StatusOK)
+	defer server.Close()
+	client, _ := NewAnonymousClient(server.URL)
+
+	err := client.Delete(URI)
+
+	c.Check(err, IsNil)
+}
+
+func (suite *ClientSuite) TestNewAuthenticatedClientParsesApiKey(c *C) {
+	// NewAuthenticatedClient returns a plainTextOAuthSigneri configured
+	// to use the given API key.
+	consumerKey := "consumerKey"
+	tokenKey := "tokenKey"
+	tokenSecret := "tokenSecret"
+	keyElements := []string{consumerKey, tokenKey, tokenSecret}
+	apiKey := strings.Join(keyElements, ":")
+
+	client, err := NewAuthenticatedClient("http://example.com/api", apiKey)
+
+	c.Check(err, IsNil)
+	signer := client.Signer.(*plainTextOAuthSigner)
+	c.Check(signer.token.ConsumerKey, Equals, consumerKey)
+	c.Check(signer.token.TokenKey, Equals, tokenKey)
+	c.Check(signer.token.TokenSecret, Equals, tokenSecret)
+}
+
+func (suite *ClientSuite) TestNewAuthenticatedClientFailsIfInvalidKey(c *C) {
+	client, err := NewAuthenticatedClient("", "invalid-key")
+
+	c.Check(err, ErrorMatches, "invalid API key.*")
+	c.Check(client, IsNil)
+
+}

=== added directory 'example'
=== added file 'example/live_example.go'
--- example/live_example.go	1970-01-01 00:00:00 +0000
+++ example/live_example.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,106 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+/*
+This is an example on how the Go library gomaasapi can be used to interact with
+a real MAAS server.
+Note that this is a provided only as an example and that real code should probably do something more sensible with errors than ignoring them or panicking.
+*/
+package main
+
+import (
+	"fmt"
+	"launchpad.net/gomaasapi"
+	"net/url"
+)
+
+var apiKey string
+var apiURL string
+
+func getParams() {
+	fmt.Println("Warning: this will create a node on the MAAS server; it should be deleted at the end of the run but if something goes wrong, that test node might be left over.  You've been warned.")
+	fmt.Print("Enter API key: ")
+	_, err := fmt.Scanf("%s", &apiKey)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Print("Enter API URL: ")
+	_, err = fmt.Scanf("%s", &apiURL)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func checkError(err error) {
+	if err != nil {
+		panic(err)
+	}
+}
+
+func main() {
+	getParams()
+	authClient, err := gomaasapi.NewAuthenticatedClient(apiURL, apiKey)
+	checkError(err)
+
+	maas := gomaasapi.NewMAAS(*authClient)
+
+	nodeListing := maas.GetSubObject("nodes")
+
+	// List nodes.
+	fmt.Println("Fetching list of nodes...")
+	listNodeObjects, err := nodeListing.CallGet("list", url.Values{})
+	checkError(err)
+	listNodes, err := listNodeObjects.GetArray()
+	checkError(err)
+	fmt.Printf("Got list of %v nodes\n", len(listNodes))
+	for index, nodeObj := range listNodes {
+		node, err := nodeObj.GetMAASObject()
+		checkError(err)
+		hostname, err := node.GetField("hostname")
+		checkError(err)
+		fmt.Printf("Node #%d is named '%v' (%v)\n", index, hostname, node.URL())
+	}
+
+	// Create a node.
+	fmt.Println("Creating a new node...")
+	params := url.Values{"architecture": {"i386/generic"}, "mac_addresses": {"AA:BB:CC:DD:EE:FF"}}
+	newNodeObj, err := nodeListing.CallPost("new", params)
+	checkError(err)
+	newNode, err := newNodeObj.GetMAASObject()
+	checkError(err)
+	newNodeName, err := newNode.GetField("hostname")
+	checkError(err)
+	fmt.Printf("New node created: %s (%s)\n", newNodeName, newNode.URL())
+
+	// Update the new node.
+	fmt.Println("Updating the new node...")
+	updateParams := url.Values{"hostname": {"mynewname"}}
+	newNodeObj2, err := newNode.Update(updateParams)
+	checkError(err)
+	newNode2, err := newNodeObj2.GetMAASObject()
+	checkError(err)
+	newNodeName2, err := newNode2.GetField("hostname")
+	checkError(err)
+	fmt.Printf("New node updated, now named: %s\n", newNodeName2)
+
+	// Count the nodes.
+	listNodeObjects2, err := nodeListing.CallGet("list", url.Values{})
+	checkError(err)
+	listNodes2, err := listNodeObjects2.GetArray()
+	checkError(err)
+	fmt.Printf("We've got %v nodes\n", len(listNodes2))
+
+	// Delete the new node.
+	fmt.Println("Deleting the new node...")
+	errDelete := newNode.Delete()
+	checkError(errDelete)
+
+	// Count the nodes.
+	listNodeObjects3, err := nodeListing.CallGet("list", url.Values{})
+	checkError(err)
+	listNodes3, err := listNodeObjects3.GetArray()
+	checkError(err)
+	fmt.Printf("We've got %v nodes\n", len(listNodes3))
+
+	fmt.Println("All done.")
+}

=== modified file 'gomaasapi.go'
--- gomaasapi.go	2013-01-22 10:29:56 +0000
+++ gomaasapi.go	2013-02-06 17:03:19 +0000
@@ -1,1 +1,4 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
 package gomaasapi

=== modified file 'gomaasapi_test.go'
--- gomaasapi_test.go	2013-01-22 10:29:56 +0000
+++ gomaasapi_test.go	2013-02-06 17:03:19 +0000
@@ -1,3 +1,6 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
 package gomaasapi
 
 import (

=== added file 'jsonobject.go'
--- jsonobject.go	1970-01-01 00:00:00 +0000
+++ jsonobject.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,197 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+)
+
+// JSONObject is a wrapper around a JSON structure which provides
+// methods to extract data from that structure.
+// A JSONObject provides a simple structure consisting of the data types
+// defined in JSON: string, number, object, list, and bool.  To get the
+// value you want out of a JSONObject, you must know (or figure out) which
+// kind of value you have, and then call the appropriate Get*() method to
+// get at it.  Reading an item as the wrong type will return an error.
+// For instance, if your JSONObject consists of a number, call GetFloat64()
+// to get the value as a float64.  If it's a list, call GetArray() to get
+// a slice of JSONObjects.  To read any given item from the slice, you'll
+// need to "Get" that as the right type as well.
+// 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)
+}
+
+// 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.
+func maasify(client Client, value interface{}) JSONObject {
+	if value == nil {
+		return nil
+	}
+	switch value.(type) {
+	case string:
+		return jsonString(value.(string))
+	case float64:
+		return jsonFloat64(value.(float64))
+	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)
+	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))
+	}
+	msg := fmt.Sprintf("Unknown JSON type, can't be converted to JSONObject: %v", value)
+	panic(msg)
+}
+
+// Parse a JSON blob into a JSONObject.
+func Parse(client Client, input []byte) (JSONObject, error) {
+	var obj interface{}
+	err := json.Unmarshal(input, &obj)
+	if err != nil {
+		return nil, 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())
+	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 }

=== added file 'jsonobject_test.go'
--- jsonobject_test.go	1970-01-01 00:00:00 +0000
+++ jsonobject_test.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,228 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	. "launchpad.net/gocheck"
+)
+
+type JSONObjectSuite struct {
+}
+
+var _ = Suite(&JSONObjectSuite{})
+
+// maasify() converts nil.
+func (suite *JSONObjectSuite) TestMaasifyConvertsNil(c *C) {
+	c.Check(maasify(Client{}, nil), Equals, nil)
+}
+
+// maasify() converts strings.
+func (suite *JSONObjectSuite) TestMaasifyConvertsString(c *C) {
+	const text = "Hello"
+	c.Check(string(maasify(Client{}, text).(jsonString)), 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)
+}
+
+// maasify() converts array slices.
+func (suite *JSONObjectSuite) TestMaasifyConvertsArray(c *C) {
+	original := []interface{}{3.0, 2.0, 1.0}
+	output := maasify(Client{}, original).(jsonArray)
+	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)
+}
+
+// maasify() converts maps.
+func (suite *JSONObjectSuite) TestMaasifyConvertsMap(c *C) {
+	original := map[string]interface{}{"1": "one", "2": "two", "3": "three"}
+	output := maasify(Client{}, original).(jsonMap)
+	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")
+}
+
+// maasify() converts MAAS objects.
+func (suite *JSONObjectSuite) TestMaasifyConvertsMAASObject(c *C) {
+	original := map[string]interface{}{
+		"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")
+}
+
+// maasify() passes its client to a MAASObject it creates.
+func (suite *JSONObjectSuite) TestMaasifyPassesInfoToMAASObject(c *C) {
+	client := Client{}
+	original := map[string]interface{}{"resource_uri": "/foo"}
+	output := maasify(client, original).(jsonMAASObject)
+	c.Check(output.client, Equals, client)
+}
+
+// maasify() passes its client into an array of MAASObjects it creates.
+func (suite *JSONObjectSuite) TestMaasifyPassesInfoIntoArray(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)
+}
+
+// maasify() passes its client into a map of MAASObjects it creates.
+func (suite *JSONObjectSuite) TestMaasifyPassesInfoIntoMap(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)
+}
+
+// maasify() passes its client all the way down into any MAASObjects in the
+// object structure it creates.
+func (suite *JSONObjectSuite) TestMaasifyPassesInfoAllTheWay(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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// String-type JSONObjects convert only to string.
+func (suite *JSONObjectSuite) TestConversionsString(c *C) {
+	obj := jsonString("Test string")
+
+	value, err := obj.GetString()
+	c.Check(err, IsNil)
+	c.Check(value, Equals, "Test string")
+
+	_, err = obj.GetFloat64()
+	c.Check(err, NotNil)
+	_, err = obj.GetMap()
+	c.Check(err, NotNil)
+	_, err = obj.GetMAASObject()
+	c.Check(err, NotNil)
+	_, err = obj.GetArray()
+	c.Check(err, NotNil)
+	_, err = obj.GetBool()
+	c.Check(err, NotNil)
+}
+
+// Number-type JSONObjects convert only to float64.
+func (suite *JSONObjectSuite) TestConversionsFloat64(c *C) {
+	obj := jsonFloat64(1.1)
+
+	value, err := obj.GetFloat64()
+	c.Check(err, IsNil)
+	c.Check(value, Equals, 1.1)
+
+	_, err = obj.GetString()
+	c.Check(err, NotNil)
+	_, err = obj.GetMap()
+	c.Check(err, NotNil)
+	_, err = obj.GetMAASObject()
+	c.Check(err, NotNil)
+	_, err = obj.GetArray()
+	c.Check(err, NotNil)
+	_, err = obj.GetBool()
+	c.Check(err, NotNil)
+}
+
+// Map-type JSONObjects convert only to map.
+func (suite *JSONObjectSuite) TestConversionsMap(c *C) {
+	input := map[string]JSONObject{"x": jsonString("y")}
+	obj := jsonMap(input)
+
+	value, err := obj.GetMap()
+	c.Check(err, IsNil)
+	text, err := value["x"].GetString()
+	c.Check(err, IsNil)
+	c.Check(text, Equals, "y")
+
+	_, err = obj.GetString()
+	c.Check(err, NotNil)
+	_, err = obj.GetFloat64()
+	c.Check(err, NotNil)
+	_, err = obj.GetMAASObject()
+	c.Check(err, NotNil)
+	_, err = obj.GetArray()
+	c.Check(err, NotNil)
+	_, err = obj.GetBool()
+	c.Check(err, NotNil)
+}
+
+// Array-type JSONObjects convert only to array.
+func (suite *JSONObjectSuite) TestConversionsArray(c *C) {
+	obj := jsonArray([]JSONObject{jsonString("item")})
+
+	value, err := obj.GetArray()
+	c.Check(err, IsNil)
+	text, err := value[0].GetString()
+	c.Check(err, IsNil)
+	c.Check(text, Equals, "item")
+
+	_, err = obj.GetString()
+	c.Check(err, NotNil)
+	_, err = obj.GetFloat64()
+	c.Check(err, NotNil)
+	_, err = obj.GetMap()
+	c.Check(err, NotNil)
+	_, err = obj.GetMAASObject()
+	c.Check(err, NotNil)
+	_, err = obj.GetBool()
+	c.Check(err, NotNil)
+}
+
+// Boolean-type JSONObjects convert only to bool.
+func (suite *JSONObjectSuite) TestConversionsBool(c *C) {
+	obj := jsonBool(false)
+
+	value, err := obj.GetBool()
+	c.Check(err, IsNil)
+	c.Check(value, Equals, false)
+
+	_, err = obj.GetString()
+	c.Check(err, NotNil)
+	_, err = obj.GetFloat64()
+	c.Check(err, NotNil)
+	_, err = obj.GetMap()
+	c.Check(err, NotNil)
+	_, err = obj.GetMAASObject()
+	c.Check(err, NotNil)
+	_, err = obj.GetArray()
+	c.Check(err, NotNil)
+}

=== added file 'maas.go'
--- maas.go	1970-01-01 00:00:00 +0000
+++ maas.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,10 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+// 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)
+}

=== added file 'maas_test.go'
--- maas_test.go	1970-01-01 00:00:00 +0000
+++ maas_test.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,22 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	. "launchpad.net/gocheck"
+	"net/url"
+)
+
+type MAASSuite struct{}
+
+var _ = Suite(&MAASSuite{})
+
+func (suite *MAASSuite) TestNewMAASUsesBaseURLFromClient(c *C) {
+	baseURLString := "https://server.com:888/path/to/api"
+	baseURL, _ := url.Parse(baseURLString)
+	client := Client{BaseURL: baseURL}
+	maas := NewMAAS(client)
+	URL := maas.URL()
+	c.Check(URL, DeepEquals, baseURL)
+}

=== added file 'maasobject.go'
--- maasobject.go	1970-01-01 00:00:00 +0000
+++ maasobject.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,167 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"errors"
+	"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
+	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]
+	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 {
+	// Duplicate the URL.
+	uri, err := url.Parse(obj.uri.String())
+	if err != nil {
+		panic(err)
+	}
+	return uri
+}
+
+func (obj jsonMAASObject) URL() *url.URL {
+	return obj.client.GetURL(obj.URI())
+}
+
+func (obj jsonMAASObject) GetSubObject(name string) MAASObject {
+	uri := obj.URI()
+	uri.Path = EnsureTrailingSlash(JoinURLs(uri.Path, name))
+	input := map[string]JSONObject{resourceURI: jsonString(uri.String())}
+	return newJSONMAASObject(jsonMap(input), obj.client)
+}
+
+var NotImplemented = errors.New("Not implemented")
+
+func (obj jsonMAASObject) Get() (MAASObject, error) {
+	uri := obj.URI()
+	result, err := obj.client.Get(uri, "", url.Values{})
+	if err != nil {
+		return nil, err
+	}
+	jsonObj, err := Parse(obj.client, result)
+	if err != nil {
+		return nil, err
+	}
+	return jsonObj.GetMAASObject()
+}
+
+func (obj jsonMAASObject) Post(params url.Values) (JSONObject, error) {
+	uri := obj.URI()
+	result, err := obj.client.Post(uri, "", params)
+	if err != nil {
+		return nil, err
+	}
+	return Parse(obj.client, result)
+}
+
+func (obj jsonMAASObject) Update(params url.Values) (MAASObject, error) {
+	uri := obj.URI()
+	result, err := obj.client.Put(uri, params)
+	if err != nil {
+		return nil, err
+	}
+	jsonObj, err := Parse(obj.client, result)
+	if err != nil {
+		return nil, err
+	}
+	return jsonObj.GetMAASObject()
+}
+
+func (obj jsonMAASObject) Delete() error {
+	uri := obj.URI()
+	return obj.client.Delete(uri)
+}
+
+func (obj jsonMAASObject) 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 Parse(obj.client, result)
+}
+
+func (obj jsonMAASObject) 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 Parse(obj.client, result)
+}

=== added file 'maasobject_test.go'
--- maasobject_test.go	1970-01-01 00:00:00 +0000
+++ maasobject_test.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,133 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"fmt"
+	. "launchpad.net/gocheck"
+	"math/rand"
+	"net/url"
+)
+
+type MAASObjectSuite struct{}
+
+var _ = Suite(&MAASObjectSuite{})
+
+func makeFakeResourceURI() string {
+	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.
+func (suite *MAASObjectSuite) TestConversionsMAASObject(c *C) {
+	input := map[string]JSONObject{resourceURI: jsonString("someplace")}
+	obj := jsonMAASObject{jsonMap: jsonMap(input)}
+
+	mp, err := obj.GetMap()
+	c.Check(err, IsNil)
+	text, err := mp[resourceURI].GetString()
+	c.Check(err, IsNil)
+	c.Check(text, Equals, "someplace")
+
+	maasobj, err := obj.GetMAASObject()
+	c.Check(err, IsNil)
+	_ = maasobj.(jsonMAASObject)
+
+	_, err = obj.GetString()
+	c.Check(err, NotNil)
+	_, err = obj.GetFloat64()
+	c.Check(err, NotNil)
+	_, err = obj.GetArray()
+	c.Check(err, NotNil)
+	_, err = obj.GetBool()
+	c.Check(err, NotNil)
+}
+
+func (suite *MAASObjectSuite) TestNewJSONMAASObjectPanicsIfNoResourceURI(c *C) {
+	defer func() {
+		recoveredError := recover()
+		c.Check(recoveredError, NotNil)
+		msg := recoveredError.(error).Error()
+		c.Check(msg, Matches, ".*no 'resource_uri' key.*")
+	}()
+	input := map[string]JSONObject{"test": jsonString("test")}
+	newJSONMAASObject(jsonMap(input), Client{})
+}
+
+func (suite *MAASObjectSuite) TestNewJSONMAASObjectPanicsIfResourceURINotString(c *C) {
+	defer func() {
+		recoveredError := recover()
+		c.Check(recoveredError, NotNil)
+		msg := recoveredError.(error).Error()
+		c.Check(msg, Matches, ".*the value of 'resource_uri' is not a string.*")
+	}()
+	input := map[string]JSONObject{resourceURI: jsonFloat64(77.7)}
+	newJSONMAASObject(jsonMap(input), Client{})
+}
+
+func (suite *MAASObjectSuite) TestNewJSONMAASObjectPanicsIfResourceURINotURL(c *C) {
+	defer func() {
+		recoveredError := recover()
+		c.Check(recoveredError, NotNil)
+		msg := recoveredError.(error).Error()
+		c.Check(msg, Matches, ".*the value of 'resource_uri' is not a valid URL.*")
+	}()
+	input := map[string]JSONObject{resourceURI: jsonString("")}
+	newJSONMAASObject(jsonMap(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{})
+	c.Check(obj.uri, DeepEquals, URI)
+}
+
+func (suite *MAASObjectSuite) TestURL(c *C) {
+	baseURL, _ := url.Parse("http://example.com/")
+	uri := "http://example.com/a/resource"
+	resourceURL, _ := url.Parse(uri)
+	input := map[string]JSONObject{resourceURI: jsonString(uri)}
+	client := Client{BaseURL: baseURL}
+	obj := newJSONMAASObject(jsonMap(input), client)
+
+	URL := obj.URL()
+
+	c.Check(URL, DeepEquals, resourceURL)
+}
+
+func (suite *MAASObjectSuite) TestGetSubObject(c *C) {
+	baseURL, _ := url.Parse("http://example.com/")
+	uri := "http://example.com/a/resource/"
+	input := map[string]JSONObject{resourceURI: jsonString(uri)}
+	client := Client{BaseURL: baseURL}
+	obj := newJSONMAASObject(jsonMap(input), client)
+	subName := "/test"
+
+	subObj := obj.GetSubObject(subName)
+	subURL := subObj.URL()
+
+	// uri ends with a slash and subName starts with one, but the two paths
+	// should be concatenated as "http://example.com/a/resource/test/".
+	expectedSubURL, _ := url.Parse("http://example.com/a/resource/test/")
+	c.Check(subURL, DeepEquals, expectedSubURL)
+}
+
+func (suite *MAASObjectSuite) TestGetField(c *C) {
+	uri := "http://example.com/a/resource"
+	fieldName := "field name"
+	fieldValue := "a value"
+	input := map[string]JSONObject{
+		resourceURI: jsonString(uri), fieldName: jsonString(fieldValue),
+	}
+	obj := jsonMAASObject{jsonMap: jsonMap(input)}
+	value, err := obj.GetField(fieldName)
+	c.Check(err, IsNil)
+	c.Check(value, Equals, fieldValue)
+}

=== added file 'oauth.go'
--- oauth.go	1970-01-01 00:00:00 +0000
+++ oauth.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,81 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"crypto/rand"
+	"fmt"
+	"math/big"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+)
+
+var nonceMax = big.NewInt(100000000)
+
+func generateNonce() (string, error) {
+	randInt, err := rand.Int(rand.Reader, nonceMax)
+	if err != nil {
+		return "", err
+	}
+	return strconv.Itoa(int(randInt.Int64())), nil
+}
+
+func generateTimestamp() string {
+	return strconv.Itoa(int(time.Now().Unix()))
+}
+
+type OAuthSigner interface {
+	OAuthSign(request *http.Request) error
+}
+
+type OAuthToken struct {
+	ConsumerKey    string
+	ConsumerSecret string
+	TokenKey       string
+	TokenSecret    string
+}
+
+// Trick to ensure *plainTextOAuthSigner implements the OAuthSigner interface.
+var _ OAuthSigner = (*plainTextOAuthSigner)(nil)
+
+type plainTextOAuthSigner struct {
+	token *OAuthToken
+	realm string
+}
+
+func NewPlainTestOAuthSigner(token *OAuthToken, realm string) (OAuthSigner, error) {
+	return &plainTextOAuthSigner{token, realm}, nil
+}
+
+// OAuthSignPLAINTEXT signs the provided request using the OAuth PLAINTEXT
+// method: http://oauth.net/core/1.0/#anchor22.
+func (signer plainTextOAuthSigner) OAuthSign(request *http.Request) error {
+
+	signature := signer.token.ConsumerSecret + `&` + signer.token.TokenSecret
+	nonce, err := generateNonce()
+	if err != nil {
+		return err
+	}
+	authData := map[string]string{
+		"realm":                  signer.realm,
+		"oauth_consumer_key":     signer.token.ConsumerKey,
+		"oauth_token":            signer.token.TokenKey,
+		"oauth_signature_method": "PLAINTEXT",
+		"oauth_signature":        signature,
+		"oauth_timestamp":        generateTimestamp(),
+		"oauth_nonce":            nonce,
+		"oauth_version":          "1.0",
+	}
+	// Build OAuth header.
+	var authHeader []string
+	for key, value := range authData {
+		authHeader = append(authHeader, fmt.Sprintf(`%s="%s"`, key, url.QueryEscape(value)))
+	}
+	strHeader := "OAuth " + strings.Join(authHeader, ", ")
+	request.Header.Add("Authorization", strHeader)
+	return nil
+}

=== added directory 'templates'
=== added file 'templates/source.go'
--- templates/source.go	1970-01-01 00:00:00 +0000
+++ templates/source.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,4 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi

=== added file 'templates/source_test.go'
--- templates/source_test.go	1970-01-01 00:00:00 +0000
+++ templates/source_test.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,13 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	. "launchpad.net/gocheck"
+)
+
+// TODO: Replace with real test functions.  Give them real names.
+func (suite *GomaasapiTestSuite) TestXXX(c *C) {
+	c.Check(2+2, Equals, 4)
+}

=== added file 'testing.go'
--- testing.go	1970-01-01 00:00:00 +0000
+++ testing.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,46 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+)
+
+type singleServingServer struct {
+	*httptest.Server
+	requestContent *string
+	requestHeader  *http.Header
+}
+
+// newSingleServingServer creates a single-serving test http server which will
+// return only one response as defined by the passed arguments.
+func newSingleServingServer(uri string, response string, code int) *singleServingServer {
+	var requestContent string
+	var requestHeader http.Header
+	var requested bool
+	handler := func(writer http.ResponseWriter, request *http.Request) {
+		if requested {
+			http.Error(writer, "Already requested", http.StatusServiceUnavailable)
+		}
+		res, err := ioutil.ReadAll(request.Body)
+		if err != nil {
+			panic(err)
+		}
+		requestContent = string(res)
+		requestHeader = request.Header
+		if request.URL.String() != uri {
+			errorMsg := fmt.Sprintf("Error 404: page not found (expected '%v', got '%v').", uri, request.URL.String())
+			http.Error(writer, errorMsg, http.StatusNotFound)
+		} else {
+			writer.WriteHeader(code)
+			fmt.Fprint(writer, response)
+		}
+		requested = true
+	}
+	server := httptest.NewServer(http.HandlerFunc(handler))
+	return &singleServingServer{server, &requestContent, &requestHeader}
+}

=== added file 'testservice.go'
--- testservice.go	1970-01-01 00:00:00 +0000
+++ testservice.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,240 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"regexp"
+)
+
+// TestMAASObject is a fake MAAS server MAASObject.
+type TestMAASObject struct {
+	MAASObject
+	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().
+func NewTestMAAS(version string) *TestMAASObject {
+	server := NewTestServer(version)
+	authClient, _ := NewAnonymousClient(server.URL + fmt.Sprintf("/api/%s/", version))
+	return &TestMAASObject{NewMAAS(*authClient), server}
+}
+
+// Close shuts down the test server.
+func (testMAASObject *TestMAASObject) Close() {
+	testMAASObject.TestServer.Close()
+}
+
+// A TestServer is an HTTP server listening on a system-chosen port on the
+// local loopback interface, which simulates the behavior of a MAAS server.
+// It is intendend for use in end-to-end HTTP tests using the gomaasapi
+// library.
+type TestServer struct {
+	*httptest.Server
+	serveMux       *http.ServeMux
+	nodes          map[string]MAASObject
+	client         Client
+	nodeOperations map[string][]string
+	version        string
+}
+
+func getNodeURI(version, systemId string) string {
+	return fmt.Sprintf("/api/%s/nodes/%s/", version, systemId)
+}
+
+// Clear clears all the fake data stored and recorded by the test server
+// (nodes, recorded operations, etc.).
+func (server *TestServer) Clear() {
+	server.nodes = make(map[string]MAASObject)
+	server.nodeOperations = make(map[string][]string)
+}
+
+// NodeOperations returns the map containing the list of the operations
+// performed for each node.
+func (server *TestServer) NodeOperations() map[string][]string {
+	return server.nodeOperations
+}
+
+func (server *TestServer) addNodeOperation(systemId, operation string) {
+	operations, present := server.nodeOperations[systemId]
+	if !present {
+		operations = []string{operation}
+	} else {
+		operations = append(operations, operation)
+	}
+	server.nodeOperations[systemId] = operations
+}
+
+// NewNode creates a MAAS node.  The provided string should be a valid json
+// 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"]
+	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
+}
+
+// Returns a map associating all the nodes' system ids with the nodes'
+// objects.
+func (server *TestServer) Nodes() map[string]MAASObject {
+	return server.nodes
+}
+
+// ChangeNode updates a node with the given key/value.
+func (server *TestServer) ChangeNode(systemId, key, value string) {
+	node, found := server.nodes[systemId]
+	if !found {
+		panic("No node with such 'system_id'.")
+	}
+	mapObj, _ := node.GetMap()
+	mapObj[key] = jsonString(value)
+}
+
+func getNodeListingURL(version string) string {
+	return fmt.Sprintf("/api/%s/nodes/", version)
+}
+
+func getNodeURLRE(version string) *regexp.Regexp {
+	reString := fmt.Sprintf("^/api/%s/nodes/([^/]*)/$", version)
+	return regexp.MustCompile(reString)
+}
+
+// NewTestServer starts and returns a new MAAS test server. The caller should call Close when finished, to shut it down.
+func NewTestServer(version string) *TestServer {
+	server := &TestServer{version: version}
+
+	serveMux := http.NewServeMux()
+	nodeListingURL := getNodeListingURL(server.version)
+	// Register handler for '/api/<version>/nodes/*'.
+	serveMux.HandleFunc(nodeListingURL, func(w http.ResponseWriter, r *http.Request) {
+		nodesHandler(server, w, r)
+	})
+
+	newServer := httptest.NewServer(serveMux)
+	client, _ := NewAnonymousClient(newServer.URL)
+	server.Server = newServer
+	server.serveMux = serveMux
+	server.client = *client
+	server.Clear()
+	return server
+}
+
+// nodesHandler handles requests for '/api/<version>/nodes/*'.
+func nodesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	values, _ := url.ParseQuery(r.URL.RawQuery)
+	op := values.Get("op")
+	nodeURLRE := getNodeURLRE(server.version)
+	nodeURLMatch := nodeURLRE.FindStringSubmatch(r.URL.Path)
+	nodeListingURL := getNodeListingURL(server.version)
+	switch {
+	case r.Method == "GET" && op == "list" && r.URL.Path == nodeListingURL:
+		// Node listing operation.
+		nodeListingHandler(server, w, r)
+	case nodeURLMatch != nil:
+		// Request for a single node.
+		nodeHandler(server, w, r, nodeURLMatch[1], op)
+	default:
+		// Default handler: not found.
+		http.NotFoundHandler().ServeHTTP(w, r)
+	}
+}
+
+func marshalNode(node MAASObject) string {
+	mapObj, _ := node.GetMap()
+	res, _ := json.Marshal(mapObj)
+	return string(res)
+
+}
+
+// nodeHandler handles requests for '/api/<version>/nodes/<system_id>/'.
+func nodeHandler(server *TestServer, w http.ResponseWriter, r *http.Request, systemId string, operation string) {
+	node, ok := server.nodes[systemId]
+	if !ok {
+		http.NotFoundHandler().ServeHTTP(w, r)
+		return
+	}
+	if r.Method == "GET" {
+		if operation == "" {
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprint(w, marshalNode(node))
+			return
+		} else {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+	}
+	if r.Method == "POST" {
+		// The only operations supported are "start", "stop" and "release".
+		if operation == "start" || operation == "stop" || operation == "release" {
+			// Record operation on node.
+			server.addNodeOperation(systemId, operation)
+
+			w.WriteHeader(http.StatusOK)
+			fmt.Fprint(w, marshalNode(node))
+			return
+		} else {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+	}
+	if r.Method == "DELETE" {
+		delete(server.nodes, systemId)
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+	http.NotFoundHandler().ServeHTTP(w, r)
+}
+
+func contains(slice []string, val string) bool {
+	for _, item := range slice {
+		if item == val {
+			return true
+		}
+	}
+	return false
+}
+
+// nodeListingHandler handles requests for '/nodes/'.
+func nodeListingHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	values, _ := url.ParseQuery(r.URL.RawQuery)
+	ids, hasId := values["id"]
+	var convertedNodes = []map[string]JSONObject{}
+	for systemId, node := range server.nodes {
+		if !hasId || contains(ids, systemId) {
+			mapp, _ := node.GetMap()
+			convertedNodes = append(convertedNodes, mapp)
+		}
+	}
+	res, _ := json.Marshal(convertedNodes)
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, string(res))
+}

=== added file 'testservice_test.go'
--- testservice_test.go	1970-01-01 00:00:00 +0000
+++ testservice_test.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,255 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"encoding/json"
+	"fmt"
+	. "launchpad.net/gocheck"
+	"net/http"
+	"net/url"
+)
+
+type TestServerSuite struct {
+	server *TestServer
+}
+
+var _ = Suite(&TestServerSuite{})
+
+func (suite *TestServerSuite) SetUpTest(c *C) {
+	server := NewTestServer("1.0")
+	suite.server = server
+}
+
+func (suite *TestServerSuite) TearDownTest(c *C) {
+	suite.server.Close()
+}
+
+func (suite *TestServerSuite) TestNewTestServerReturnsTestServer(c *C) {
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusAccepted)
+	}
+	suite.server.serveMux.HandleFunc("/test/", handler)
+	resp, err := http.Get(suite.server.Server.URL + "/test/")
+
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusAccepted)
+}
+
+func (suite *TestServerSuite) TestGetResourceURI(c *C) {
+	c.Check(getNodeURI("version", "test"), Equals, "/api/version/nodes/test/")
+}
+
+func (suite *TestServerSuite) TestHandlesNodeListingUnknownPath(c *C) {
+	invalidPath := fmt.Sprintf("/api/%s/nodes/invalid/path/", suite.server.version)
+	resp, err := http.Get(suite.server.Server.URL + invalidPath)
+
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusNotFound)
+}
+
+func (suite *TestServerSuite) TestNewNode(c *C) {
+	input := `{"system_id": "mysystemid"}`
+
+	newNode := suite.server.NewNode(input)
+
+	c.Check(len(suite.server.nodes), Equals, 1)
+	c.Check(suite.server.nodes["mysystemid"], DeepEquals, newNode)
+}
+
+func (suite *TestServerSuite) TestNodesReturnsNodes(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	newNode := suite.server.NewNode(input)
+
+	nodesMap := suite.server.Nodes()
+
+	c.Check(len(nodesMap), Equals, 1)
+	c.Check(nodesMap["mysystemid"], DeepEquals, newNode)
+}
+
+func (suite *TestServerSuite) TestChangeNode(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	suite.server.NewNode(input)
+	suite.server.ChangeNode("mysystemid", "newfield", "newvalue")
+
+	node, _ := suite.server.nodes["mysystemid"]
+	mapObj, _ := node.GetMap()
+	field, _ := mapObj["newfield"].GetString()
+	c.Check(field, Equals, "newvalue")
+}
+
+func (suite *TestServerSuite) TestClearClearsData(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	suite.server.NewNode(input)
+	suite.server.addNodeOperation("mysystemid", "start")
+
+	suite.server.Clear()
+
+	c.Check(len(suite.server.nodes), Equals, 0)
+	c.Check(len(suite.server.nodeOperations), Equals, 0)
+}
+
+func (suite *TestServerSuite) TestAddNodeOperationPopulatesOperations(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	suite.server.NewNode(input)
+
+	suite.server.addNodeOperation("mysystemid", "start")
+	suite.server.addNodeOperation("mysystemid", "stop")
+
+	nodeOperations := suite.server.NodeOperations()
+	operations := nodeOperations["mysystemid"]
+	c.Check(operations, DeepEquals, []string{"start", "stop"})
+}
+
+func (suite *TestServerSuite) TestNewNodeRequiresJSONString(c *C) {
+	input := `invalid:json`
+	defer func() {
+		recoveredError := recover().(*json.SyntaxError)
+		c.Check(recoveredError, NotNil)
+		c.Check(recoveredError.Error(), Matches, ".*invalid character.*")
+	}()
+	suite.server.NewNode(input)
+}
+
+func (suite *TestServerSuite) TestNewNodeRequiresSystemIdKey(c *C) {
+	input := `{"test": "test"}`
+	defer func() {
+		recoveredError := recover()
+		c.Check(recoveredError, NotNil)
+		c.Check(recoveredError, Matches, ".*does not contain a 'system_id' value.")
+	}()
+	suite.server.NewNode(input)
+}
+
+func (suite *TestServerSuite) TestHandlesNodeRequestNotFound(c *C) {
+	getURI := fmt.Sprintf("/api/%s/nodes/test/", suite.server.version)
+	resp, err := http.Get(suite.server.Server.URL + getURI)
+
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusNotFound)
+}
+
+func (suite *TestServerSuite) TestHandlesNodeUnknownOperation(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	suite.server.NewNode(input)
+	postURI := fmt.Sprintf("/api/%s/nodes/mysystemid/?op=unknown/", suite.server.version)
+	respStart, err := http.Post(suite.server.Server.URL+postURI, "", nil)
+
+	c.Check(err, IsNil)
+	c.Check(respStart.StatusCode, Equals, http.StatusBadRequest)
+}
+
+func (suite *TestServerSuite) TestHandlesNodeDelete(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	suite.server.NewNode(input)
+	deleteURI := fmt.Sprintf("/api/%s/nodes/mysystemid/?op=mysystemid", suite.server.version)
+	req, err := http.NewRequest("DELETE", suite.server.Server.URL+deleteURI, nil)
+	client := &http.Client{}
+	resp, err := client.Do(req)
+
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusOK)
+	c.Check(len(suite.server.nodes), Equals, 0)
+}
+
+// TestMAASObjectSuite validates that the object created by
+// TestMAASObject can be used by the gomaasapi library as if it were a real
+// MAAS server.
+type TestMAASObjectSuite struct {
+	TestMAASObject *TestMAASObject
+}
+
+var _ = Suite(&TestMAASObjectSuite{})
+
+func (s *TestMAASObjectSuite) SetUpSuite(c *C) {
+	s.TestMAASObject = NewTestMAAS("1.0")
+}
+
+func (s *TestMAASObjectSuite) TearDownSuite(c *C) {
+	s.TestMAASObject.Close()
+}
+
+func (s *TestMAASObjectSuite) TearDownTest(c *C) {
+	s.TestMAASObject.TestServer.Clear()
+}
+
+func (suite *TestMAASObjectSuite) TestListNodes(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	suite.TestMAASObject.TestServer.NewNode(input)
+	nodeListing := suite.TestMAASObject.GetSubObject("nodes")
+
+	listNodeObjects, err := nodeListing.CallGet("list", url.Values{})
+
+	c.Check(err, IsNil)
+	listNodes, err := listNodeObjects.GetArray()
+	c.Check(err, IsNil)
+	c.Check(len(listNodes), Equals, 1)
+	node, _ := listNodes[0].GetMAASObject()
+	systemId, _ := node.GetField("system_id")
+	c.Check(systemId, Equals, "mysystemid")
+	resourceURI, _ := node.GetField(resourceURI)
+	expectedResourceURI := fmt.Sprintf("/api/%s/nodes/mysystemid/", suite.TestMAASObject.TestServer.version)
+	c.Check(resourceURI, Equals, expectedResourceURI)
+}
+
+func (suite *TestMAASObjectSuite) TestListNodesNoNodes(c *C) {
+	nodeListing := suite.TestMAASObject.GetSubObject("nodes")
+	listNodeObjects, err := nodeListing.CallGet("list", url.Values{})
+	c.Check(err, IsNil)
+
+	listNodes, err := listNodeObjects.GetArray()
+
+	c.Check(err, IsNil)
+	c.Check(listNodes, DeepEquals, []JSONObject{})
+}
+
+func (suite *TestMAASObjectSuite) TestListNodesSelectedNodes(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	suite.TestMAASObject.TestServer.NewNode(input)
+	input2 := `{"system_id": "mysystemid2"}`
+	suite.TestMAASObject.TestServer.NewNode(input2)
+	nodeListing := suite.TestMAASObject.GetSubObject("nodes")
+
+	listNodeObjects, err := nodeListing.CallGet("list", url.Values{"id": {"mysystemid2"}})
+
+	c.Check(err, IsNil)
+	listNodes, err := listNodeObjects.GetArray()
+	c.Check(err, IsNil)
+	c.Check(len(listNodes), Equals, 1)
+	node, _ := listNodes[0].GetMAASObject()
+	systemId, _ := node.GetField("system_id")
+	c.Check(systemId, Equals, "mysystemid2")
+}
+
+func (suite *TestMAASObjectSuite) TestDeleteNode(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	node := suite.TestMAASObject.TestServer.NewNode(input)
+
+	err := node.Delete()
+
+	c.Check(err, IsNil)
+	c.Check(suite.TestMAASObject.TestServer.Nodes(), DeepEquals, map[string]MAASObject{})
+}
+
+func (suite *TestMAASObjectSuite) TestOperationsOnNode(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	node := suite.TestMAASObject.TestServer.NewNode(input)
+	operations := []string{"start", "stop", "release"}
+	for _, operation := range operations {
+		_, err := node.CallPost(operation, url.Values{})
+		c.Check(err, IsNil)
+	}
+}
+
+func (suite *TestMAASObjectSuite) TestOperationsOnNodeGetRecorded(c *C) {
+	input := `{"system_id": "mysystemid"}`
+	node := suite.TestMAASObject.TestServer.NewNode(input)
+
+	_, err := node.CallPost("start", url.Values{})
+
+	c.Check(err, IsNil)
+	nodeOperations := suite.TestMAASObject.TestServer.NodeOperations()
+	operations := nodeOperations["mysystemid"]
+	c.Check(operations, DeepEquals, []string{"start"})
+}

=== added file 'util.go'
--- util.go	1970-01-01 00:00:00 +0000
+++ util.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,27 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"strings"
+)
+
+// JoinURLs joins a base URL and a subpath together.
+// Regardless of whether baseURL ends in a trailing slash (or even multiple
+// trailing slashes), or whether there are any leading slashes at the begining
+// of path, the two will always be joined together by a single slash.
+func JoinURLs(baseURL, path string) string {
+	return strings.TrimRight(baseURL, "/") + "/" + strings.TrimLeft(path, "/")
+}
+
+// EnsureTrailingSlash appends a slash at the end of the given string unless
+// there already is one.
+// This is used to create the kind of normalized URLs that Django expects.
+// (to avoid Django's redirection when an URL does not ends with a slash.)
+func EnsureTrailingSlash(URL string) string {
+	if strings.HasSuffix(URL, "/") {
+		return URL
+	}
+	return URL + "/"
+}

=== added file 'util_test.go'
--- util_test.go	1970-01-01 00:00:00 +0000
+++ util_test.go	2013-02-06 17:03:19 +0000
@@ -0,0 +1,32 @@
+// Copyright 2013 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	. "launchpad.net/gocheck"
+)
+
+func (suite *GomaasapiTestSuite) TestJoinURLsAppendsPathToBaseURL(c *C) {
+	c.Check(JoinURLs("http://example.com/", "foo"), Equals, "http://example.com/foo")
+}
+
+func (suite *GomaasapiTestSuite) TestJoinURLsAddsSlashIfNeeded(c *C) {
+	c.Check(JoinURLs("http://example.com/foo", "bar"), Equals, "http://example.com/foo/bar")
+}
+
+func (suite *GomaasapiTestSuite) TestJoinURLsNormalizesDoubleSlash(c *C) {
+	c.Check(JoinURLs("http://example.com/base/", "/szot"), Equals, "http://example.com/base/szot")
+}
+
+func (suite *GomaasapiTestSuite) TestEnsureTrailingSlashAppendsSlashIfMissing(c *C) {
+	c.Check(EnsureTrailingSlash("test"), Equals, "test/")
+}
+
+func (suite *GomaasapiTestSuite) TestEnsureTrailingSlashDoesNotAppendIfPresent(c *C) {
+	c.Check(EnsureTrailingSlash("test/"), Equals, "test/")
+}
+
+func (suite *GomaasapiTestSuite) TestEnsureTrailingSlashReturnsSlashIfEmpty(c *C) {
+	c.Check(EnsureTrailingSlash(""), Equals, "/")
+}