Merge lp:~mfoord/gomaasapi/nodegroupsinterfaces into lp:gomaasapi

[Michael Foord]

Add nodegroups-interfaces endpoint for TestServer. Also fix bug in nodegroups listing when there are no nodegroups.

[Dimiter Naydenov (dimitern)]

Great! Just a few trivial suggestions. I'd suggest asking for a second review from rvba or allenap.

review: Approve

[lp:~mfoord/gomaasapi/nodegroupsinterfaces]

65. By Michael Foord on 2015-01-09

Minor tweaks from review

[Gavin Panella (allenap)]

Looks good. One question inline.

review: Approve

=== modified file 'testservice.go'
--- testservice.go	2014-10-20 14:17:24 +0000
+++ testservice.go	2015-01-09 10:04:33 +0000
@@ -82,6 +82,9 @@
 	zones                       map[string]JSONObject
 	// bootImages is a map of nodegroup UUIDs to boot-image objects.
 	bootImages map[string][]JSONObject
+	// nodegroupsInterfaces is a map of nodegroup UUIDs to interface
+	// objects.
+	nodegroupsInterfaces map[string][]JSONObject
 }
 
 func getNodesEndpoint(version string) string {
@@ -150,6 +153,11 @@
 	return fmt.Sprintf("/api/%s/nodegroups/%s/", version, uuid)
 }
 
+func getNodegroupsInterfacesURLRE(version string) *regexp.Regexp {
+	reString := fmt.Sprintf("^/api/%s/nodegroups/([^/]*)/interfaces/$", regexp.QuoteMeta(version))
+	return regexp.MustCompile(reString)
+}
+
 func getBootimagesURLRE(version string) *regexp.Regexp {
 	reString := fmt.Sprintf("^/api/%s/nodegroups/([^/]*)/boot-images/$", regexp.QuoteMeta(version))
 	return regexp.MustCompile(reString)
@@ -175,6 +183,7 @@
 	server.macAddressesPerNetwork = make(map[string]map[string]JSONObject)
 	server.nodeDetails = make(map[string]string)
 	server.bootImages = make(map[string][]JSONObject)
+	server.nodegroupsInterfaces = make(map[string][]JSONObject)
 	server.zones = make(map[string]JSONObject)
 }
 
@@ -363,6 +372,28 @@
 	return obj
 }
 
+// NewNodegroupInterface adds a nodegroup-interface, for the specified
+// nodegroup,  in the test MAAS server.
+func (server *TestServer) NewNodegroupInterface(uuid, jsonText string) JSONObject {
+	_, ok := server.bootImages[uuid]
+	if !ok {
+		panic("no nodegroup with the given UUID")
+	}
+	var attrs map[string]interface{}
+	err := json.Unmarshal([]byte(jsonText), &attrs)
+	checkError(err)
+	requiredMembers := []string{"ip_range_high", "ip_range_low", "broadcast_ip", "static_ip_range_low", "static_ip_range_high", "name", "ip", "subnet_mask", "management", "interface"}
+	for _, member := range requiredMembers {
+		_, hasMember := attrs[member]
+		if !hasMember {
+			panic(fmt.Sprintf("The given map json string does not contain a required %q", member))
+		}
+	}
+	obj := maasify(server.client, attrs)
+	server.nodegroupsInterfaces[uuid] = append(server.nodegroupsInterfaces[uuid], obj)
+	return obj
+}
+
 func (server *TestServer) ConnectNodeToNetwork(systemId, name string) {
 	_, hasNode := server.nodes[systemId]
 	if !hasNode {
@@ -465,6 +496,7 @@
 	serveMux.HandleFunc(nodegroupsURL, func(w http.ResponseWriter, r *http.Request) {
 		nodegroupsHandler(server, w, r)
 	})
+
 	// Register handler for '/api/<version>/zones/*'.
 	zonesURL := getZonesEndpoint(server.version)
 	serveMux.HandleFunc(zonesURL, func(w http.ResponseWriter, r *http.Request) {
@@ -1095,12 +1127,16 @@
 	op := values.Get("op")
 	bootimagesURLRE := getBootimagesURLRE(server.version)
 	bootimagesURLMatch := bootimagesURLRE.FindStringSubmatch(r.URL.Path)
+	nodegroupsInterfacesURLRE := getNodegroupsInterfacesURLRE(server.version)
+	nodegroupsInterfacesURLMatch := nodegroupsInterfacesURLRE.FindStringSubmatch(r.URL.Path)
 	nodegroupsURL := getNodegroupsEndpoint(server.version)
 	switch {
 	case r.URL.Path == nodegroupsURL:
 		nodegroupsTopLevelHandler(server, w, r, op)
 	case bootimagesURLMatch != nil:
 		bootimagesHandler(server, w, r, bootimagesURLMatch[1], op)
+	case nodegroupsInterfacesURLMatch != nil:
+		nodegroupsInterfacesHandler(server, w, r, nodegroupsInterfacesURLMatch[1], op)
 	default:
 		// Default handler: not found.
 		http.NotFoundHandler().ServeHTTP(w, r)
@@ -1114,7 +1150,7 @@
 		return
 	}
 
-	var nodegroups []JSONObject
+	nodegroups := []JSONObject{}
 	for uuid := range server.bootImages {
 		attrs := map[string]interface{}{
 			"uuid":      uuid,
@@ -1149,6 +1185,29 @@
 	fmt.Fprint(w, string(res))
 }
 
+// nodegroupsInterfacesHandler handles requests for '/api/<version>/nodegroups/<uuid>/interfaces/'
+func nodegroupsInterfacesHandler(server *TestServer, w http.ResponseWriter, r *http.Request, nodegroupUUID, op string) {
+	if r.Method != "GET" {
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+	_, ok := server.bootImages[nodegroupUUID]
+	if !ok {
+		http.NotFoundHandler().ServeHTTP(w, r)
+		return
+	}
+
+	interfaces, ok := server.nodegroupsInterfaces[nodegroupUUID]
+	if !ok {
+		// we already checked the nodegroup exists, so return an empty list
+		interfaces = []JSONObject{}
+	}
+	res, err := json.Marshal(interfaces)
+	checkError(err)
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, string(res))
+}
+
 // zonesHandler handles requests for '/api/<version>/zones/'.
 func zonesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
 	if r.Method != "GET" {

=== modified file 'testservice_test.go'
--- testservice_test.go	2014-10-20 14:17:24 +0000
+++ testservice_test.go	2015-01-09 10:04:33 +0000
@@ -66,6 +66,14 @@
 	c.Check(resp.StatusCode, Equals, http.StatusNotFound)
 }
 
+func (suite *TestServerSuite) TestHandlesNodegroupsInterfacesListingUnknownNodegroup(c *C) {
+	invalidPath := fmt.Sprintf("/api/%s/nodegroups/unknown/interfaces/", 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"}`
 
@@ -971,6 +979,74 @@
 	}
 }
 
+func (suite *TestMAASObjectSuite) TestListNodegroupsEmptyList(c *C) {
+	nodegroupListing := suite.TestMAASObject.GetSubObject("nodegroups")
+	result, err := nodegroupListing.CallGet("list", nil)
+	c.Assert(err, IsNil)
+
+	nodegroups, err := result.GetArray()
+	c.Assert(err, IsNil)
+	c.Check(nodegroups, HasLen, 0)
+}
+
+func (suite *TestMAASObjectSuite) TestListNodegroupInterfaces(c *C) {
+	suite.TestMAASObject.TestServer.AddBootImage("uuid-0", `{"architecture": "arm64", "release": "trusty"}`)
+	jsonText := `{
+            "ip_range_high": "172.16.0.128",
+            "ip_range_low": "172.16.0.2",
+            "broadcast_ip": "172.16.0.255",
+            "static_ip_range_low": "172.16.0.129",
+            "name": "eth0",
+            "ip": "172.16.0.2",
+            "subnet_mask": "255.255.255.0",
+            "management": 2,
+            "static_ip_range_high": "172.16.0.255",
+            "interface": "eth0"
+        }`
+
+	suite.TestMAASObject.TestServer.NewNodegroupInterface("uuid-0", jsonText)
+	nodegroupsInterfacesListing := suite.TestMAASObject.GetSubObject("nodegroups").GetSubObject("uuid-0").GetSubObject("interfaces")
+	result, err := nodegroupsInterfacesListing.CallGet("list", nil)
+	c.Assert(err, IsNil)
+
+	nodegroupsInterfaces, err := result.GetArray()
+	c.Assert(err, IsNil)
+	c.Check(nodegroupsInterfaces, HasLen, 1)
+
+	nodegroupsInterface, err := nodegroupsInterfaces[0].GetMap()
+	c.Assert(err, IsNil)
+
+	checkMember := func(member, expectedValue string) {
+		value, err := nodegroupsInterface[member].GetString()
+		c.Assert(err, IsNil)
+		c.Assert(value, Equals, expectedValue)
+	}
+	checkMember("ip_range_high", "172.16.0.128")
+	checkMember("ip_range_low", "172.16.0.2")
+	checkMember("broadcast_ip", "172.16.0.255")
+	checkMember("static_ip_range_low", "172.16.0.129")
+	checkMember("static_ip_range_high", "172.16.0.255")
+	checkMember("name", "eth0")
+	checkMember("ip", "172.16.0.2")
+	checkMember("subnet_mask", "255.255.255.0")
+	checkMember("interface", "eth0")
+
+	value, err := nodegroupsInterface["management"].GetFloat64()
+	c.Assert(err, IsNil)
+	c.Assert(value, Equals, 2.0)
+}
+
+func (suite *TestMAASObjectSuite) TestListNodegroupsInterfacesEmptyList(c *C) {
+	suite.TestMAASObject.TestServer.AddBootImage("uuid-0", `{"architecture": "arm64", "release": "trusty"}`)
+	nodegroupsInterfacesListing := suite.TestMAASObject.GetSubObject("nodegroups").GetSubObject("uuid-0").GetSubObject("interfaces")
+	result, err := nodegroupsInterfacesListing.CallGet("list", nil)
+	c.Assert(err, IsNil)
+
+	interfaces, err := result.GetArray()
+	c.Assert(err, IsNil)
+	c.Check(interfaces, HasLen, 0)
+}
+
 func (suite *TestMAASObjectSuite) TestListBootImages(c *C) {
 	suite.TestMAASObject.TestServer.AddBootImage("uuid-0", `{"architecture": "arm64", "release": "trusty"}`)
 	suite.TestMAASObject.TestServer.AddBootImage("uuid-1", `{"architecture": "amd64", "release": "precise"}`)