Merge lp:~axwalk/gomaasapi/maas-testserver-zones into lp:gomaasapi

[Andrew Wilkins]

Add "zones" handler to test service, so we can simulate MAAS installations with and without support for physical zones. This will be used in Juju to test zone placement and distribution.

Also, filter nodes when acquiring (by name, or by zone).

Add "zones" handler to test service, so we can simulate MAAS installations with and without support for physical zones. This will be used in Juju to test zone placement and distribution.

Also, filter nodes when acquiring (by name, or by zone).

[Ian Booth (wallyworld)]

There needs to be tests added to testservice_test.go for the new zones functionality.
I also don't understand how the agent_name filtering works.

[Andrew Wilkins (axwalk)]

Will add tests.

[lp:~axwalk/gomaasapi/maas-testserver-zones]

56. By Andrew Wilkins on 2014-10-15

Add zones tests

[Ian Booth (wallyworld)]

review: Approve

=== modified file 'testservice.go'
--- testservice.go	2014-09-15 04:14:56 +0000
+++ testservice.go	2014-10-15 03:13:00 +0000
@@ -75,6 +75,7 @@
 	version                     string
 	macAddressesPerNetwork      map[string]map[string]JSONObject
 	nodeDetails                 map[string]string
+	zones                       map[string]JSONObject
 	// bootImages is a map of nodegroup UUIDs to boot-image objects.
 	bootImages map[string][]JSONObject
 }
@@ -146,6 +147,10 @@
 	return regexp.MustCompile(reString)
 }
 
+func getZonesEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/zones/", version)
+}
+
 // Clear clears all the fake data stored and recorded by the test server
 // (nodes, recorded operations, etc.).
 func (server *TestServer) Clear() {
@@ -161,6 +166,7 @@
 	server.macAddressesPerNetwork = make(map[string]map[string]JSONObject)
 	server.nodeDetails = make(map[string]string)
 	server.bootImages = make(map[string][]JSONObject)
+	server.zones = make(map[string]JSONObject)
 }
 
 // NodesOperations returns the list of operations performed at the /nodes/
@@ -190,26 +196,25 @@
 
 func parseRequestValues(request *http.Request) url.Values {
 	var requestValues url.Values
-	if request.Body != nil && request.Header.Get("Content-Type") == "application/x-www-form-urlencoded" {
-		body, err := readAndClose(request.Body)
-		if err != nil {
-			panic(err)
-		}
-		requestValues, err = url.ParseQuery(string(body))
-		if err != nil {
-			panic(err)
-		}
+	if request.Header.Get("Content-Type") == "application/x-www-form-urlencoded" {
+		if request.PostForm == nil {
+			if err := request.ParseForm(); err != nil {
+				panic(err)
+			}
+		}
+		requestValues = request.PostForm
 	}
 	return requestValues
 }
 
-func (server *TestServer) addNodesOperation(operation string, request *http.Request) {
+func (server *TestServer) addNodesOperation(operation string, request *http.Request) url.Values {
 	requestValues := parseRequestValues(request)
 	server.nodesOperations = append(server.nodesOperations, operation)
 	server.nodesOperationRequestValues = append(server.nodesOperationRequestValues, requestValues)
+	return requestValues
 }
 
-func (server *TestServer) addNodeOperation(systemId, operation string, request *http.Request) {
+func (server *TestServer) addNodeOperation(systemId, operation string, request *http.Request) url.Values {
 	operations, present := server.nodeOperations[systemId]
 	operationRequestValues, present2 := server.nodeOperationRequestValues[systemId]
 	if present != present2 {
@@ -225,6 +230,7 @@
 	}
 	server.nodeOperations[systemId] = operations
 	server.nodeOperationRequestValues[systemId] = operationRequestValues
+	return requestValues
 }
 
 // NewNode creates a MAAS node.  The provided string should be a valid json
@@ -367,6 +373,16 @@
 	server.bootImages[nodegroupUUID] = append(server.bootImages[nodegroupUUID], obj)
 }
 
+// AddZone adds a physical zone to the server.
+func (server *TestServer) AddZone(name, description string) {
+	attrs := map[string]interface{}{
+		"name":        name,
+		"description": description,
+	}
+	obj := maasify(server.client, attrs)
+	server.zones[name] = obj
+}
+
 // 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}
@@ -397,6 +413,11 @@
 	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) {
+		zonesHandler(server, w, r)
+	})
 
 	newServer := httptest.NewServer(serveMux)
 	client, err := NewAnonymousClient(newServer.URL, "1.0")
@@ -500,20 +521,53 @@
 	fmt.Fprint(w, string(res))
 }
 
-// findFreeNode looks for a node that is currently available.
-func findFreeNode(server *TestServer) *MAASObject {
+// findFreeNode looks for a node that is currently available, and
+// matches the specified filter.
+func findFreeNode(server *TestServer, filter url.Values) *MAASObject {
 	for systemID, node := range server.Nodes() {
 		_, present := server.OwnedNodes()[systemID]
 		if !present {
+			var agentName, nodeName, zoneName string
+			for k := range filter {
+				switch k {
+				case "agent_name":
+					agentName = filter.Get(k)
+				case "name":
+					nodeName = filter.Get(k)
+				case "zone":
+					zoneName = filter.Get(k)
+				}
+			}
+			if nodeName != "" && !matchField(node, "hostname", nodeName) {
+				continue
+			}
+			if zoneName != "" && !matchField(node, "zone", zoneName) {
+				continue
+			}
+			if agentName != "" {
+				agentNameObj := maasify(server.client, agentName)
+				node.GetMap()["agent_name"] = agentNameObj
+			} else {
+				delete(node.GetMap(), "agent_name")
+			}
 			return &node
 		}
 	}
 	return nil
 }
 
+func matchField(node MAASObject, k, v string) bool {
+	field, err := node.GetField(k)
+	if err != nil {
+		return false
+	}
+	return field == v
+}
+
 // nodesAcquireHandler simulates acquiring a node.
 func nodesAcquireHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
-	node := findFreeNode(server)
+	requestValues := server.addNodesOperation("acquire", r)
+	node := findFreeNode(server, requestValues)
 	if node == nil {
 		w.WriteHeader(http.StatusConflict)
 	} else {
@@ -888,3 +942,28 @@
 	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" {
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	if len(server.zones) == 0 {
+		// Until a zone is registered, behave as if the endpoint
+		// does not exist. This way we can simulate older MAAS
+		// servers that do not support zones.
+		http.NotFoundHandler().ServeHTTP(w, r)
+		return
+	}
+
+	zones := make([]JSONObject, 0, len(server.zones))
+	for _, zone := range server.zones {
+		zones = append(zones, zone)
+	}
+	res, err := json.Marshal(zones)
+	checkError(err)
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprint(w, string(res))
+}

=== modified file 'testservice_test.go'
--- testservice_test.go	2014-09-15 05:07:10 +0000
+++ testservice_test.go	2014-10-15 03:13:00 +0000
@@ -357,6 +357,16 @@
 	c.Check(suite.server.Files(), DeepEquals, map[string]MAASObject{})
 }
 
+func (suite *TestServerSuite) TestListZonesNotSupported(c *C) {
+	// Older versions of MAAS do not support zones. We simulate
+	// this behaviour by returning 404 if no zones are defined.
+	zonesURL := getZonesEndpoint(suite.server.version)
+	resp, err := http.Get(suite.server.Server.URL + zonesURL)
+
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusNotFound)
+}
+
 // TestMAASObjectSuite validates that the object created by
 // NewTestMAAS can be used by the gomaasapi library as if it were a real
 // MAAS server.
@@ -845,3 +855,74 @@
 	sort.Strings(bootImages)
 	c.Assert(bootImages, DeepEquals, expectedBootImages)
 }
+
+func (suite *TestMAASObjectSuite) TestListZones(c *C) {
+	expected := map[string]string{
+		"zone0": "zone0 is very nice",
+		"zone1": "zone1 is much nicer than zone0",
+	}
+	for name, desc := range expected {
+		suite.TestMAASObject.TestServer.AddZone(name, desc)
+	}
+
+	result, err := suite.TestMAASObject.GetSubObject("zones").CallGet("", nil)
+	c.Assert(err, IsNil)
+	c.Assert(result, NotNil)
+
+	list, err := result.GetArray()
+	c.Assert(err, IsNil)
+	c.Assert(list, HasLen, len(expected))
+
+	m := make(map[string]string)
+	for _, item := range list {
+		itemMap, err := item.GetMap()
+		c.Assert(err, IsNil)
+		name, err := itemMap["name"].GetString()
+		c.Assert(err, IsNil)
+		desc, err := itemMap["description"].GetString()
+		c.Assert(err, IsNil)
+		m[name] = desc
+	}
+	c.Assert(m, DeepEquals, expected)
+}
+
+func (suite *TestMAASObjectSuite) TestAcquireNodeZone(c *C) {
+	suite.TestMAASObject.TestServer.AddZone("z0", "rox")
+	suite.TestMAASObject.TestServer.AddZone("z1", "sux")
+	suite.TestMAASObject.TestServer.NewNode(`{"system_id": "n0", "zone": "z0"}`)
+	suite.TestMAASObject.TestServer.NewNode(`{"system_id": "n1", "zone": "z1"}`)
+	suite.TestMAASObject.TestServer.NewNode(`{"system_id": "n2", "zone": "z1"}`)
+	nodesObj := suite.TestMAASObject.GetSubObject("nodes")
+
+	acquire := func(zone string) (string, string, error) {
+		var params url.Values
+		if zone != "" {
+			params = url.Values{"zone": []string{zone}}
+		}
+		jsonResponse, err := nodesObj.CallPost("acquire", params)
+		if err != nil {
+			return "", "", err
+		}
+		acquiredNode, err := jsonResponse.GetMAASObject()
+		c.Assert(err, IsNil)
+		systemId, err := acquiredNode.GetField("system_id")
+		c.Assert(err, IsNil)
+		assignedZone, err := acquiredNode.GetField("zone")
+		c.Assert(err, IsNil)
+		if zone != "" {
+			c.Assert(assignedZone, Equals, zone)
+		}
+		return systemId, assignedZone, nil
+	}
+
+	id, _, err := acquire("z0")
+	c.Assert(err, IsNil)
+	c.Assert(id, Equals, "n0")
+	id, _, err = acquire("z0")
+	c.Assert(err.(ServerError).StatusCode, Equals, http.StatusConflict)
+
+	id, zone, err := acquire("")
+	c.Assert(err, IsNil)
+	c.Assert(id, Not(Equals), "n0")
+	c.Assert(zone, Equals, "z1")
+}