Merge lp:~klyachin/gomaasapi/101-testserver-extensions into lp:gomaasapi

[Vladislav Klyachin]

testservice: version/network/details support

These changes are for juju-core project testing. They include new API endpoints:

- /version/
  return capabilities, currently only networks-management
- /network/<name>/?op=list_connected_macs
  returns list of MAC addresses connected to a network
- /nodes/<system_id>/?op=details
  returns lshw XML as application/bson, the XML data should be added before with AddNodeDetails(systemId, xml) function

Now for API endpoint:
  /networks?node=system_id
TestService returns empty list if node is not found or no networks are connected to the node.
It panicked before.

https://codereview.appspot.com/86070043/

R=dimitern, klyachin, rvb

testservice: version/network/details support

These changes are for juju-core project testing. They include new API endpoints:

- /version/
  return capabilities, currently only networks-management
- /network/<name>/?op=list_connected_macs
  returns list of MAC addresses connected to a network
- /nodes/<system_id>/?op=details
  returns lshw XML as application/bson, the XML data should be added before with AddNodeDetails(systemId, xml) function

Now for API endpoint:
  /networks?node=system_id
TestService returns empty list if node is not found or no networks are connected to the node.
It panicked before.

https://codereview.appspot.com/86070043/

[Vladislav Klyachin (klyachin)]

Please take a look.

[Vladislav Klyachin (klyachin)]

Please take a look.

[Vladislav Klyachin (klyachin)]

Reviewers: mp+214961_code.launchpad.net,

Message:
Please take a look.

Description:
testservice: version/network/details support

These changes are for juju-core project testing. They include new API
endpoints:

- /version/
   return capabilities, currently only networks-management
- /network/<name>/?op=list_connected_macs
   returns list of MAC addresses connected to a network
- /nodes/<system_id>/?op=details
   returns lshw XML as application/bson, the XML data should be added
before with AddNodeDetails(systemId, xml) function

Now for API endpoint:
   /networks?node=system_id
TestService returns empty list if node is not found or no networks are
connected to the node.
It panicked before.

https://code.launchpad.net/~klyachin/gomaasapi/101-testserver-extensions/+merge/214961

(do not edit description out of merge proposal)

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

Affected files (+277, -6 lines):
   A [revision details]
   M testservice.go
   M testservice_test.go

[Raphaël Badin (rvb)]

LGTM with a couple of remarks.

https://codereview.appspot.com/86070043/diff/1/testservice.go
File testservice.go (right):

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode482
testservice.go:482: // AddNodeDetails srores node details, expected in
XML format.
typo: stores

https://codereview.appspot.com/86070043/diff/1/testservice_test.go
File testservice_test.go (right):

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode647
testservice_test.go:647: expectedResourceURI =
fmt.Sprintf("/api/%s/nodes/mysystemid/macs/aa%%3Abb%%3Acc%%3Add%%3Aee%%3Aff/",
apiVersion)
Probably better to express this as the url-escaped version of
'aa:bb:cc:dd:ee:ff'. Here and elsewhere.

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode669
testservice_test.go:669: c.Assert(err, IsNil)
This is a bit awkward, can we check the entire set instead of picking
the first node and testing that?

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode718
testservice_test.go:718: xmlText := `<?xml version="1.0"
standalone="yes" ?>
It's a detail but don't we have a equivalent to Python textwrap.dedent
to better format this?

https://codereview.appspot.com/86070043/

[Dimiter Naydenov (dimitern)]

Looks almost there, but I have a few suggestions below:

https://codereview.appspot.com/86070043/diff/1/testservice.go
File testservice.go (right):

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode279
testservice.go:279: func (server *TestServer)
ConnectNodeToNetworkWithMACAddress(systemId, name, macAddress string) {
s/name/networkName/ ?

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode282
testservice.go:282: panic("no node with given system id")
s/given/the given/ ?

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode284
testservice.go:284: _, hasNetwork := server.networks[name]
or:

if _, hasNetwork := server.networks[name]; !hasNetwork {
...
}

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode300
testservice.go:300: } else {
No need for that else block.

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode332
testservice.go:332: // Register handler for '/api/version/'.
... for '/api/<version>/version/'

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode494
testservice.go:494: attrs["lldp"] = []byte("<?xml version=\"1.0\"
encoding=\"UTF-8\"?>\n<lldp label=\"LLDP neighbors\"/>")
Can you define:

const lldpXML = `
<?xml version="1.0" encoding="UTF-8"?>
<lldp label="LLDP neighbors"/>
`

...and use it here? It will look better I think.

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode664
testservice.go:664: // networkListingConnectedMACSHandler handles
requests for '/api/<version>/networks/<network>/?op=list_connected_macs'
s/Listing/List/ ?

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode673
testservice.go:673: var convertedMacAddresses =
[]map[string]JSONObject{}
Or just convertedMacAddresses := []map[string]JSONObject{}

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode701
testservice.go:701: panic("only list_connected_macs operation
implemented")
"only list_connected_macs and default operations implemented" ?

(default: op=="")

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode708
testservice.go:708: if !hasNetworks {
I think you can skip this case and just leave the else part (Marshal
should work with empty slices just the same as with nil slices I hope).

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode723
testservice.go:723: // versionHandler handles requests for
'/api/version/'.
'/api/<version>/version/'

https://codereview.appspot.com/86070043/diff/1/testservice_test.go
File testservice_test.go (right):

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode624
testservice_test.go:624: c.Check(err, IsNil)
Assert on errors, rather than Check, that way if it's not what you
expect the test case is halted immediately, rather than blowing up down
the line (see gocheck docs about Assert vs. Check).

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode627
testservice_test.go:627: c.Check(len(listNodes), Equals, 1)
c.Check(listNodes, HasLen, 1)

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode640
testservice_test.go:640: c.Check(len(macAddressSet), Equals, 1)...

[lp:~klyachin/gomaasapi/101-testserver-extensions]

50. By Vladislav Klyachin on 2014-04-09

Made suggested changes

[Vladislav Klyachin (klyachin)]

Please take a look.

https://codereview.appspot.com/86070043/

[Vladislav Klyachin (klyachin)]

On 2014/04/09 15:19:48, rvb wrote:
> LGTM with a couple of remarks.

> https://codereview.appspot.com/86070043/diff/1/testservice.go
> File testservice.go (right):

https://codereview.appspot.com/86070043/diff/1/testservice.go#newcode482
> testservice.go:482: // AddNodeDetails srores node details, expected in
XML
> format.
> typo: stores
Done.

> https://codereview.appspot.com/86070043/diff/1/testservice_test.go
> File testservice_test.go (right):

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode647
> testservice_test.go:647: expectedResourceURI =

fmt.Sprintf("/api/%s/nodes/mysystemid/macs/aa%%3Abb%%3Acc%%3Add%%3Aee%%3Aff/",
> apiVersion)
> Probably better to express this as the url-escaped version of
> 'aa:bb:cc:dd:ee:ff'. Here and elsewhere.
Done.

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode669
> testservice_test.go:669: c.Assert(err, IsNil)
> This is a bit awkward, can we check the entire set instead of picking
the first
> node and testing that?
The problem is that mac addresses can be in an arbitrary order.
Golang language spec explicitly defines maps as having undefined
ordering of keys.

https://codereview.appspot.com/86070043/diff/1/testservice_test.go#newcode718
> testservice_test.go:718: xmlText := `<?xml version="1.0"
standalone="yes" ?>
> It's a detail but don't we have a equivalent to Python textwrap.dedent
to better
> format this?
Didn't find dedent analogue in Go.
Moved text to a string constant outside of the function.

https://codereview.appspot.com/86070043/

[Vladislav Klyachin (klyachin)]

On 2014/04/09 15:58:23, dimitern wrote:
> Looks almost there, but I have a few suggestions below:

Thanks for the review, dimitern. All changes suggested were made.

https://codereview.appspot.com/86070043/

[Dimiter Naydenov (dimitern)]

On 2014/04/09 17:10:23, vladislav.klyachin wrote:
> On 2014/04/09 15:58:23, dimitern wrote:
> > Looks almost there, but I have a few suggestions below:
> >
> Thanks for the review, dimitern. All changes suggested were made.

Thanks, LGTM!

https://codereview.appspot.com/86070043/

=== modified file 'testservice.go'
--- testservice.go	2014-04-01 14:47:23 +0000
+++ testservice.go	2014-04-09 17:04:10 +0000
@@ -9,6 +9,7 @@
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"labix.org/v2/mgo/bson"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
@@ -66,6 +67,8 @@
 	networks                   map[string]MAASObject
 	networksPerNode            map[string][]string
 	version                    string
+	macAddressesPerNetwork     map[string]map[string]JSONObject
+	nodeDetails                map[string]string
 }
 
 func getNodesEndpoint(version string) string {
@@ -105,6 +108,23 @@
 	return fmt.Sprintf("/api/%s/networks/%s/", version, name)
 }
 
+func getNetworkURLRE(version string) *regexp.Regexp {
+	reString := fmt.Sprintf("^/api/%s/networks/(.*)/$", regexp.QuoteMeta(version))
+	return regexp.MustCompile(reString)
+}
+
+func getMACAddressURL(version, systemId, macAddress string) string {
+	return fmt.Sprintf("/api/%s/nodes/%s/macs/%s/", version, systemId, url.QueryEscape(macAddress))
+}
+
+func getVersionURL(version string) string {
+	return fmt.Sprintf("/api/%s/version/", version)
+}
+
+func getVersionJSON() string {
+	return `{"capabilities": ["networks-management"]}`
+}
+
 // Clear clears all the fake data stored and recorded by the test server
 // (nodes, recorded operations, etc.).
 func (server *TestServer) Clear() {
@@ -115,6 +135,8 @@
 	server.files = make(map[string]MAASObject)
 	server.networks = make(map[string]MAASObject)
 	server.networksPerNode = make(map[string][]string)
+	server.macAddressesPerNetwork = make(map[string]map[string]JSONObject)
+	server.nodeDetails = make(map[string]string)
 }
 
 // NodeOperations returns the map containing the list of the operations
@@ -244,16 +266,45 @@
 func (server *TestServer) ConnectNodeToNetwork(systemId, name string) {
 	_, hasNode := server.nodes[systemId]
 	if !hasNode {
-		panic("no node with given system id")
+		panic("no node with the given system id")
 	}
 	_, hasNetwork := server.networks[name]
 	if !hasNetwork {
-		panic("no network with given name")
+		panic("no network with the given name")
 	}
 	networkNames, _ := server.networksPerNode[systemId]
 	server.networksPerNode[systemId] = append(networkNames, name)
 }
 
+func (server *TestServer) ConnectNodeToNetworkWithMACAddress(systemId, networkName, macAddress string) {
+	node, hasNode := server.nodes[systemId]
+	if !hasNode {
+		panic("no node with the given system id")
+	}
+	if _, hasNetwork := server.networks[networkName]; !hasNetwork {
+		panic("no network with the given name")
+	}
+	networkNames, _ := server.networksPerNode[systemId]
+	server.networksPerNode[systemId] = append(networkNames, networkName)
+	attrs := make(map[string]interface{})
+	attrs[resourceURI] = getMACAddressURL(server.version, systemId, macAddress)
+	attrs["mac_address"] = macAddress
+	array := []JSONObject{}
+	if set, ok := node.GetMap()["macaddress_set"]; ok {
+		var err error
+		array, err = set.GetArray()
+		if err != nil {
+			panic(err)
+		}
+	}
+	array = append(array, maasify(server.client, attrs))
+	node.GetMap()["macaddress_set"] = JSONObject{value: array, client: server.client}
+	if _, ok := server.macAddressesPerNetwork[networkName]; !ok {
+		server.macAddressesPerNetwork[networkName] = map[string]JSONObject{}
+	}
+	server.macAddressesPerNetwork[networkName][systemId] = maasify(server.client, attrs)
+}
+
 // 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}
@@ -274,6 +325,11 @@
 	serveMux.HandleFunc(networksURL, func(w http.ResponseWriter, r *http.Request) {
 		networksHandler(server, w, r)
 	})
+	versionURL := getVersionURL(server.version)
+	// Register handler for '/api/<version>/version/'.
+	serveMux.HandleFunc(versionURL, func(w http.ResponseWriter, r *http.Request) {
+		versionHandler(server, w, r)
+	})
 
 	newServer := httptest.NewServer(serveMux)
 	client, err := NewAnonymousClient(newServer.URL, "1.0")
@@ -317,6 +373,9 @@
 			w.WriteHeader(http.StatusOK)
 			fmt.Fprint(w, marshalNode(node))
 			return
+		} else if operation == "details" {
+			nodeDetailsHandler(server, w, r, systemId)
+			return
 		} else {
 			w.WriteHeader(http.StatusBadRequest)
 			return
@@ -417,6 +476,32 @@
 	}
 }
 
+// AddNodeDetails stores node details, expected in XML format.
+func (server *TestServer) AddNodeDetails(systemId, xmlText string) {
+	_, hasNode := server.nodes[systemId]
+	if !hasNode {
+		panic("no node with the given system id")
+	}
+	server.nodeDetails[systemId] = xmlText
+}
+
+const lldpXML = `
+<?xml version="1.0" encoding="UTF-8"?>
+<lldp label="LLDP neighbors"/>`
+
+// nodeDetailesHandler handles requests for '/api/<version>/nodes/<system_id>/?op=details'.
+func nodeDetailsHandler(server *TestServer, w http.ResponseWriter, r *http.Request, systemId string) {
+	attrs := make(map[string]interface{})
+	attrs["lldp"] = lldpXML
+	xmlText, _ := server.nodeDetails[systemId]
+	attrs["lshw"] = []byte(xmlText)
+	res, err := bson.Marshal(attrs)
+	checkError(err)
+	w.Header().Set("Content-Type", "application/bson")
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, string(res))
+}
+
 // filesHandler handles requests for '/api/<version>/files/*'.
 func filesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
 	values, err := url.ParseQuery(r.URL.RawQuery)
@@ -577,6 +662,29 @@
 	w.WriteHeader(http.StatusOK)
 }
 
+// networkListConnectedMACSHandler handles requests for '/api/<version>/networks/<network>/?op=list_connected_macs'
+func networkListConnectedMACSHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	networkURLRE := getNetworkURLRE(server.version)
+	networkURLREMatch := networkURLRE.FindStringSubmatch(r.URL.Path)
+	if networkURLREMatch == nil {
+		http.NotFoundHandler().ServeHTTP(w, r)
+		return
+	}
+	networkName := networkURLREMatch[1]
+	convertedMacAddresses := []map[string]JSONObject{}
+	if macAddresses, ok := server.macAddressesPerNetwork[networkName]; ok {
+		for _, macAddress := range macAddresses {
+			m, err := macAddress.GetMap()
+			checkError(err)
+			convertedMacAddresses = append(convertedMacAddresses, m)
+		}
+	}
+	res, err := json.Marshal(convertedMacAddresses)
+	checkError(err)
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, string(res))
+}
+
 // networksHandler handles requests for '/api/<version>/networks/?node=system_id'.
 func networksHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
 	if r.Method != "GET" {
@@ -584,21 +692,38 @@
 	}
 	values, err := url.ParseQuery(r.URL.RawQuery)
 	checkError(err)
+	op := values.Get("op")
 	systemId := values.Get("node")
+	if op == "list_connected_macs" {
+		networkListConnectedMACSHandler(server, w, r)
+		return
+	}
+	if op != "" {
+		panic("only list_connected_macs and default operations implemented")
+	}
 	if systemId == "" {
 		panic("network missing associated node system id")
 	}
-	networkNames, hasNetworks := server.networksPerNode[systemId]
-	if !hasNetworks {
-		// TODO(gz): Should be an HTTP error not a panic
-		panic("no networks exists for the given node system id")
-	}
-	networks := make([]MAASObject, len(networkNames))
-	for i, networkName := range networkNames {
-		networks[i] = server.networks[networkName]
+	networks := []MAASObject{}
+	if networkNames, hasNetworks := server.networksPerNode[systemId]; hasNetworks {
+		networks = make([]MAASObject, len(networkNames))
+		for i, networkName := range networkNames {
+			networks[i] = server.networks[networkName]
+		}
 	}
 	res, err := json.Marshal(networks)
 	checkError(err)
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
 }
+
+// versionHandler handles requests for '/api/<version>/version/'.
+func versionHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	if r.Method != "GET" {
+		panic("only version GET operation implemented")
+	}
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, getVersionJSON())
+}

=== modified file 'testservice_test.go'
--- testservice_test.go	2014-04-01 14:47:23 +0000
+++ testservice_test.go	2014-04-09 17:04:10 +0000
@@ -9,6 +9,7 @@
 	"encoding/json"
 	"fmt"
 	"io"
+	"labix.org/v2/mgo/bson"
 	. "launchpad.net/gocheck"
 	"mime/multipart"
 	"net/http"
@@ -595,3 +596,155 @@
 	c.Assert(err, IsNil)
 	c.Check(networkName, Equals, "mynetworkname")
 }
+
+func (suite *TestMAASObjectSuite) TestGetNetworksNone(c *C) {
+	nodeJSON := `{"system_id": "mysystemid"}`
+	suite.TestMAASObject.TestServer.NewNode(nodeJSON)
+
+	networkMethod := suite.TestMAASObject.GetSubObject("networks")
+	params := url.Values{"node": []string{"mysystemid"}}
+	listNetworkObjects, err := networkMethod.CallGet("", params)
+	c.Assert(err, IsNil)
+
+	networkJSONArray, err := listNetworkObjects.GetArray()
+	c.Assert(err, IsNil)
+	c.Check(networkJSONArray, HasLen, 0)
+}
+
+func (suite *TestMAASObjectSuite) TestListNodesWithNetworks(c *C) {
+	nodeJSON := `{"system_id": "mysystemid"}`
+	suite.TestMAASObject.TestServer.NewNode(nodeJSON)
+	networkJSON := `{"name": "mynetworkname"}`
+	suite.TestMAASObject.TestServer.NewNetwork(networkJSON)
+	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("mysystemid", "mynetworkname", "aa:bb:cc:dd:ee:ff")
+
+	nodeListing := suite.TestMAASObject.GetSubObject("nodes")
+	listNodeObjects, err := nodeListing.CallGet("list", url.Values{})
+	c.Assert(err, IsNil)
+
+	listNodes, err := listNodeObjects.GetArray()
+	c.Assert(err, IsNil)
+	c.Check(listNodes, HasLen, 1)
+
+	node, err := listNodes[0].GetMAASObject()
+	c.Assert(err, IsNil)
+	systemId, err := node.GetField("system_id")
+	c.Assert(err, IsNil)
+	c.Check(systemId, Equals, "mysystemid")
+
+	gotResourceURI, err := node.GetField(resourceURI)
+	c.Assert(err, IsNil)
+	apiVersion := suite.TestMAASObject.TestServer.version
+	expectedResourceURI := fmt.Sprintf("/api/%s/nodes/mysystemid/", apiVersion)
+	c.Check(gotResourceURI, Equals, expectedResourceURI)
+
+	macAddressSet, err := node.GetMap()["macaddress_set"].GetArray()
+	c.Assert(err, IsNil)
+	c.Check(macAddressSet, HasLen, 1)
+
+	macAddress, err := macAddressSet[0].GetMap()
+	c.Assert(err, IsNil)
+	macAddressString, err := macAddress["mac_address"].GetString()
+	c.Check(macAddressString, Equals, "aa:bb:cc:dd:ee:ff")
+
+	gotResourceURI, err = macAddress[resourceURI].GetString()
+	c.Assert(err, IsNil)
+	expectedResourceURI = fmt.Sprintf("/api/%s/nodes/mysystemid/macs/%s/", apiVersion, url.QueryEscape("aa:bb:cc:dd:ee:ff"))
+	c.Check(gotResourceURI, Equals, expectedResourceURI)
+}
+
+func (suite *TestMAASObjectSuite) TestListNetworkConnectedMACAddresses(c *C) {
+	suite.TestMAASObject.TestServer.NewNode(`{"system_id": "node_1"}`)
+	suite.TestMAASObject.TestServer.NewNode(`{"system_id": "node_2"}`)
+	suite.TestMAASObject.TestServer.NewNetwork(`{"name": "net_1"}`)
+	suite.TestMAASObject.TestServer.NewNetwork(`{"name": "net_2"}`)
+	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("node_2", "net_2", "aa:bb:cc:dd:ee:22")
+	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("node_1", "net_1", "aa:bb:cc:dd:ee:11")
+	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("node_2", "net_1", "aa:bb:cc:dd:ee:21")
+	suite.TestMAASObject.TestServer.ConnectNodeToNetworkWithMACAddress("node_1", "net_2", "aa:bb:cc:dd:ee:12")
+
+	nodeListing := suite.TestMAASObject.GetSubObject("networks").GetSubObject("net_1")
+	listNodeObjects, err := nodeListing.CallGet("list_connected_macs", url.Values{})
+	c.Assert(err, IsNil)
+
+	listNodes, err := listNodeObjects.GetArray()
+	c.Assert(err, IsNil)
+	c.Check(listNodes, HasLen, 2)
+
+	node, err := listNodes[0].GetMAASObject()
+	c.Assert(err, IsNil)
+	macAddress, err := node.GetField("mac_address")
+	c.Assert(err, IsNil)
+	c.Check(macAddress == "aa:bb:cc:dd:ee:11" || macAddress == "aa:bb:cc:dd:ee:21", Equals, true)
+	node1_idx := 0
+	if macAddress == "aa:bb:cc:dd:ee:21" {
+		node1_idx = 1
+	}
+
+	node, err = listNodes[node1_idx].GetMAASObject()
+	c.Assert(err, IsNil)
+	macAddress, err = node.GetField("mac_address")
+	c.Assert(err, IsNil)
+	c.Check(macAddress, Equals, "aa:bb:cc:dd:ee:11")
+	nodeResourceURI, err := node.GetField(resourceURI)
+	c.Assert(err, IsNil)
+	apiVersion := suite.TestMAASObject.TestServer.version
+	expectedResourceURI := fmt.Sprintf("/api/%s/nodes/node_1/macs/%s/", apiVersion, url.QueryEscape("aa:bb:cc:dd:ee:11"))
+	c.Check(nodeResourceURI, Equals, expectedResourceURI)
+
+	node, err = listNodes[1-node1_idx].GetMAASObject()
+	c.Assert(err, IsNil)
+	macAddress, err = node.GetField("mac_address")
+	c.Assert(err, IsNil)
+	c.Check(macAddress, Equals, "aa:bb:cc:dd:ee:21")
+	nodeResourceURI, err = node.GetField(resourceURI)
+	c.Assert(err, IsNil)
+	expectedResourceURI = fmt.Sprintf("/api/%s/nodes/node_2/macs/%s/", apiVersion, url.QueryEscape("aa:bb:cc:dd:ee:21"))
+	c.Check(nodeResourceURI, Equals, expectedResourceURI)
+}
+
+func (suite *TestMAASObjectSuite) TestGetVersion(c *C) {
+	networkMethod := suite.TestMAASObject.GetSubObject("version")
+	params := url.Values{"node": []string{"mysystemid"}}
+	versionObject, err := networkMethod.CallGet("", params)
+	c.Assert(err, IsNil)
+
+	versionMap, err := versionObject.GetMap()
+	c.Assert(err, IsNil)
+	jsonArray, ok := versionMap["capabilities"]
+	c.Check(ok, Equals, true)
+	capArray, err := jsonArray.GetArray()
+	for _, capJSONName := range capArray {
+		capName, err := capJSONName.GetString()
+		c.Assert(err, IsNil)
+		c.Check(capName, Equals, "networks-management")
+	}
+}
+
+const nodeDetailsXML = `<?xml version="1.0" standalone="yes" ?>
+<list>
+<node id="node2" claimed="true" class="system" handle="DMI:0001">
+ <description>Computer</description>
+</node>
+</list>`
+
+func (suite *TestMAASObjectSuite) TestNodeDetails(c *C) {
+	nodeJSON := `{"system_id": "mysystemid"}`
+	suite.TestMAASObject.TestServer.NewNode(nodeJSON)
+	suite.TestMAASObject.TestServer.AddNodeDetails("mysystemid", nodeDetailsXML)
+
+	obj := suite.TestMAASObject.GetSubObject("nodes").GetSubObject("mysystemid")
+	uri := obj.URI()
+	result, err := obj.client.Get(uri, "details", nil)
+	c.Assert(err, IsNil)
+
+	bsonObj := map[string]interface{}{}
+	err = bson.Unmarshal(result, &bsonObj)
+	c.Assert(err, IsNil)
+
+	_, ok := bsonObj["lldp"]
+	c.Check(ok, Equals, true)
+	gotXMLText, ok := bsonObj["lshw"]
+	c.Check(ok, Equals, true)
+	c.Check(string(gotXMLText.([]byte)), Equals, string(nodeDetailsXML))
+}