Merge lp:~dooferlad/gomaasapi/subnets into lp:gomaasapi

[James Tunnicliffe]

Add subnets support.

[Dimiter Naydenov (dimitern)]

Most of it looks good, apart from a few concerns around marshalling/unmarshalling for numbers and reducing some duplication.

review: Needs Fixing

[James Tunnicliffe (dooferlad)]

Don't worry about the JSON stuff - it works just fine if you use structs because go can convert according to the type you give it. The de-dup stuff seems worth it though.

[lp:~dooferlad/gomaasapi/subnets]

72. By James Tunnicliffe on 2015-11-24

Pretty JSON is easier to read.
Fixed api/1.0/subnets/1/?op=reserved_ip_ranges when there is 1 reserved address.

73. By James Tunnicliffe on 2015-11-24

Fixed incorrect JSON name for space

74. By James Tunnicliffe on 2015-11-24

New addresses default to having a purpose of "assigned-ip"
Added AddFixedAddressRange call.
De-duplicated some code.

75. By James Tunnicliffe on 2015-11-24

Purpose back to being an array.
Fixed possible out of range error.

76. By James Tunnicliffe on 2015-11-26

AddFixedAddressRange moved to the server rather than directly acting on a subnet.

77. By James Tunnicliffe on 2015-11-26

suite.server.SetNodeNetworkLink now takes a node.SystemID rather than a node.

78. By James Tunnicliffe on 2015-11-26

Fixed subnets/1/?op=reserved_ip_ranges when no IP addresses had been explicitly assigned.

[James Tunnicliffe (dooferlad)]

Now working well enough for voidspace to use. Please take another look.

review: Resubmit

[Michael Foord (mfoord)]

The json encoding serialises uninitialised slices as null, which is incompatible with MAAS and will break clients that expect an empty array. Other than that looks good to me.

review: Needs Fixing

[lp:~dooferlad/gomaasapi/subnets]

79. By James Tunnicliffe on 2015-11-27

Ensure that all arrays in a posted subnet are non-nil.
Fix typo.
Simplify net.IP --> uint64 logic.

[Michael Foord (mfoord)]

LGTM

review: Approve

=== modified file 'jsonobject.go'
--- jsonobject.go	2013-02-12 12:26:07 +0000
+++ jsonobject.go	2015-11-27 13:51:56 +0000
@@ -104,6 +104,15 @@
 	return obj, nil
 }
 
+// JSONObjectFromStruct takes a struct and converts it to a JSONObject
+func JSONObjectFromStruct(client Client, input interface{}) (JSONObject, error) {
+	j, err := json.MarshalIndent(input, "", "  ")
+	if err != nil {
+		return JSONObject{}, err
+	}
+	return Parse(client, j)
+}
+
 // Return error value for failed type conversion.
 func failConversion(wantedType string, obj JSONObject) error {
 	msg := fmt.Sprintf("Requested %v, got %T.", wantedType, obj.value)
@@ -116,7 +125,7 @@
 	if obj.IsNil() {
 		return json.Marshal(nil)
 	}
-	return json.Marshal(obj.value)
+	return json.MarshalIndent(obj.value, "", "  ")
 }
 
 // With MarshalJSON, JSONObject implements json.Marshaler.

=== modified file 'maasobject.go'
--- maasobject.go	2013-03-04 12:13:33 +0000
+++ maasobject.go	2015-11-27 13:51:56 +0000
@@ -36,14 +36,14 @@
 
 // MarshalJSON tells the standard json package how to serialize a MAASObject.
 func (obj MAASObject) MarshalJSON() ([]byte, error) {
-	return json.Marshal(obj.GetMap())
+	return json.MarshalIndent(obj.GetMap(), "", "  ")
 }
 
 // With MarshalJSON, MAASObject implements json.Marshaler.
 var _ json.Marshaler = (*MAASObject)(nil)
 
 func marshalNode(node MAASObject) string {
-	res, _ := json.Marshal(node)
+	res, _ := json.MarshalIndent(node, "", "  ")
 	return string(res)
 
 }

=== modified file 'testservice.go'
--- testservice.go	2015-07-02 16:26:22 +0000
+++ testservice.go	2015-11-27 13:51:56 +0000
@@ -74,6 +74,7 @@
 	// list of Values passed when performing operations at the
 	// /nodes/ level.
 	nodesOperationRequestValues []url.Values
+	nodeMetadata                map[string]Node
 	files                       map[string]MAASObject
 	networks                    map[string]MAASObject
 	networksPerNode             map[string][]string
@@ -94,6 +95,15 @@
 
 	// devices is a map of device UUIDs to devices.
 	devices map[string]*device
+
+	subnets        map[uint]Subnet
+	subnetNameToID map[string]uint
+	nextSubnet     uint
+	spaces         map[uint]Space
+	spaceNameToID  map[string]uint
+	nextSpace      uint
+	vlans          map[int]VLAN
+	nextVLAN       int
 }
 
 type device struct {
@@ -205,6 +215,7 @@
 	server.nodeOperations = make(map[string][]string)
 	server.nodesOperationRequestValues = make([]url.Values, 0)
 	server.nodeOperationRequestValues = make(map[string][]url.Values)
+	server.nodeMetadata = make(map[string]Node)
 	server.files = make(map[string]MAASObject)
 	server.networks = make(map[string]MAASObject)
 	server.networksPerNode = make(map[string][]string)
@@ -214,8 +225,16 @@
 	server.bootImages = make(map[string][]JSONObject)
 	server.nodegroupsInterfaces = make(map[string][]JSONObject)
 	server.zones = make(map[string]JSONObject)
-	server.versionJSON = `{"capabilities": ["networks-management","static-ipaddresses"]}`
+	server.versionJSON = `{"capabilities": ["networks-management","static-ipaddresses","devices-management","network-deployment-ubuntu"]}`
 	server.devices = make(map[string]*device)
+	server.subnets = make(map[uint]Subnet)
+	server.subnetNameToID = make(map[string]uint)
+	server.nextSubnet = 1
+	server.spaces = make(map[uint]Space)
+	server.spaceNameToID = make(map[string]uint)
+	server.nextSpace = 1
+	server.vlans = make(map[int]VLAN)
+	server.nextVLAN = 1
 }
 
 // SetVersionJSON sets the JSON response (capabilities) returned from the
@@ -355,18 +374,34 @@
 }
 
 // NewIPAddress creates a new static IP address reservation for the
-// given network and ipAddress.
-func (server *TestServer) NewIPAddress(ipAddress, network string) {
-	if _, found := server.networks[network]; !found {
-		panic("No such network: " + network)
+// given network/subnet and ipAddress. While networks is being deprecated
+// try the given name as both a netowrk and a subnet.
+func (server *TestServer) NewIPAddress(ipAddress, networkOrSubnet string) {
+	_, foundNetwork := server.networks[networkOrSubnet]
+	subnetID, foundSubnet := server.subnetNameToID[networkOrSubnet]
+
+	if (foundNetwork || foundSubnet) == false {
+		panic("No such network or subnet: " + networkOrSubnet)
 	}
-	ips, found := server.ipAddressesPerNetwork[network]
-	if found {
-		ips = append(ips, ipAddress)
+	if foundNetwork {
+		ips, found := server.ipAddressesPerNetwork[networkOrSubnet]
+		if found {
+			ips = append(ips, ipAddress)
+		} else {
+			ips = []string{ipAddress}
+		}
+		server.ipAddressesPerNetwork[networkOrSubnet] = ips
 	} else {
-		ips = []string{ipAddress}
+		subnet := server.subnets[subnetID]
+		netIp := net.ParseIP(ipAddress)
+		if netIp == nil {
+			panic(ipAddress + " is invalid")
+		}
+		ip := IPFromNetIP(netIp)
+		ip.Purpose = []string{"assigned-ip"}
+		subnet.InUseIPAddresses = append(subnet.InUseIPAddresses, ip)
+		server.subnets[subnetID] = subnet
 	}
-	server.ipAddressesPerNetwork[network] = ips
 }
 
 // RemoveIPAddress removes the given existing ipAddress and returns
@@ -545,6 +580,21 @@
 		zonesHandler(server, w, r)
 	})
 
+	subnetsURL := getSubnetsEndpoint(server.version)
+	serveMux.HandleFunc(subnetsURL, func(w http.ResponseWriter, r *http.Request) {
+		subnetsHandler(server, w, r)
+	})
+
+	spacesURL := getSpacesEndpoint(server.version)
+	serveMux.HandleFunc(spacesURL, func(w http.ResponseWriter, r *http.Request) {
+		spacesHandler(server, w, r)
+	})
+
+	vlansURL := getVLANsEndpoint(server.version)
+	serveMux.HandleFunc(vlansURL, func(w http.ResponseWriter, r *http.Request) {
+		vlansHandler(server, w, r)
+	})
+
 	newServer := httptest.NewServer(serveMux)
 	client, err := NewAnonymousClient(newServer.URL, "1.0")
 	checkError(err)
@@ -785,12 +835,27 @@
 		http.NotFoundHandler().ServeHTTP(w, r)
 		return
 	}
+	UUID, UUIDError := node.values["system_id"].GetString()
+
 	if r.Method == "GET" {
 		if operation == "" {
 			w.WriteHeader(http.StatusOK)
+			if UUIDError == nil {
+				i, err := JSONObjectFromStruct(server.client, server.nodeMetadata[UUID].Interfaces)
+				checkError(err)
+				if err == nil {
+					node.values["interface_set"] = i
+				}
+			}
 			fmt.Fprint(w, marshalNode(node))
 			return
 		} else if operation == "details" {
+			if UUIDError == nil {
+				i, err := JSONObjectFromStruct(server.client, server.nodeMetadata[UUID].Interfaces)
+				if err == nil {
+					node.values["interface_set"] = i
+				}
+			}
 			nodeDetailsHandler(server, w, r, systemId)
 			return
 		} else {
@@ -811,10 +876,10 @@
 			w.WriteHeader(http.StatusOK)
 			fmt.Fprint(w, marshalNode(node))
 			return
-		} else {
-			w.WriteHeader(http.StatusBadRequest)
-			return
 		}
+
+		w.WriteHeader(http.StatusBadRequest)
+		return
 	}
 	if r.Method == "DELETE" {
 		delete(server.nodes, systemId)
@@ -844,7 +909,7 @@
 			convertedNodes = append(convertedNodes, node.GetMap())
 		}
 	}
-	res, err := json.Marshal(convertedNodes)
+	res, err := json.MarshalIndent(convertedNodes, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
@@ -872,7 +937,7 @@
 		}
 	}
 	obj := maasify(server.client, nodeStatus)
-	res, err := json.Marshal(obj)
+	res, err := json.MarshalIndent(obj, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
@@ -971,7 +1036,7 @@
 		systemId, err := node.GetField("system_id")
 		checkError(err)
 		server.OwnedNodes()[systemId] = true
-		res, err := json.Marshal(node)
+		res, err := json.MarshalIndent(node, "", "  ")
 		checkError(err)
 		// Record operation.
 		server.addNodeOperation(systemId, "acquire", r)
@@ -1005,7 +1070,7 @@
 		node := server.Nodes()[systemId]
 		releasedNodes = append(releasedNodes, node.GetMap())
 	}
-	res, err := json.Marshal(releasedNodes)
+	res, err := json.MarshalIndent(releasedNodes, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
@@ -1121,7 +1186,7 @@
 		fileMap := stripContent(server.files[filename].GetMap())
 		convertedFiles = append(convertedFiles, fileMap)
 	}
-	res, err := json.Marshal(convertedFiles)
+	res, err := json.MarshalIndent(convertedFiles, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
@@ -1141,7 +1206,7 @@
 			http.NotFoundHandler().ServeHTTP(w, r)
 			return
 		}
-		jsonText, err := json.Marshal(file)
+		jsonText, err := json.MarshalIndent(file, "", "  ")
 		if err != nil {
 			panic(err)
 		}
@@ -1233,7 +1298,7 @@
 			convertedMacAddresses = append(convertedMacAddresses, m)
 		}
 	}
-	res, err := json.Marshal(convertedMacAddresses)
+	res, err := json.MarshalIndent(convertedMacAddresses, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
@@ -1265,7 +1330,7 @@
 			networks[i] = server.networks[networkName]
 		}
 	}
-	res, err := json.Marshal(networks)
+	res, err := json.MarshalIndent(networks, "", "  ")
 	checkError(err)
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	w.WriteHeader(http.StatusOK)
@@ -1331,7 +1396,7 @@
 			results = append(results, maasObj)
 		}
 	}
-	res, err := json.Marshal(results)
+	res, err := json.MarshalIndent(results, "", "  ")
 	checkError(err)
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	w.WriteHeader(http.StatusOK)
@@ -1407,7 +1472,7 @@
 	checkError(err)
 	maasObj, err := jsonObj.GetMAASObject()
 	checkError(err)
-	res, err := json.Marshal(maasObj)
+	res, err := json.MarshalIndent(maasObj, "", "  ")
 	checkError(err)
 	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	w.WriteHeader(http.StatusOK)
@@ -1476,7 +1541,7 @@
 		nodegroups = append(nodegroups, obj)
 	}
 
-	res, err := json.Marshal(nodegroups)
+	res, err := json.MarshalIndent(nodegroups, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
@@ -1495,7 +1560,7 @@
 		return
 	}
 
-	res, err := json.Marshal(bootImages)
+	res, err := json.MarshalIndent(bootImages, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
@@ -1518,7 +1583,7 @@
 		// we already checked the nodegroup exists, so return an empty list
 		interfaces = []JSONObject{}
 	}
-	res, err := json.Marshal(interfaces)
+	res, err := json.MarshalIndent(interfaces, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))
@@ -1543,7 +1608,7 @@
 	for _, zone := range server.zones {
 		zones = append(zones, zone)
 	}
-	res, err := json.Marshal(zones)
+	res, err := json.MarshalIndent(zones, "", "  ")
 	checkError(err)
 	w.WriteHeader(http.StatusOK)
 	fmt.Fprint(w, string(res))

=== added file 'testservice_spaces.go'
--- testservice_spaces.go	1970-01-01 00:00:00 +0000
+++ testservice_spaces.go	2015-11-27 13:51:56 +0000
@@ -0,0 +1,81 @@
+// Copyright 2015 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"
+	"regexp"
+)
+
+func getSpacesEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/spaces/", version)
+}
+
+// Space is the MAAS API space representation
+type Space struct {
+	Name        string   `json:"name"`
+	Subnets     []Subnet `json:"subnets"`
+	ResourceURI string   `json:"resource_uri"`
+	ID          uint     `json:"id"`
+}
+
+// spacesHandler handles requests for '/api/<version>/spaces/'.
+func spacesHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	var err error
+	spacesURLRE := regexp.MustCompile(`/spaces/(.+?)/`)
+	spacesURLMatch := spacesURLRE.FindStringSubmatch(r.URL.Path)
+	spacesURL := getSpacesEndpoint(server.version)
+
+	var ID uint
+	var gotID bool
+	if spacesURLMatch != nil {
+		ID, err = NameOrIDToID(spacesURLMatch[1], server.spaceNameToID, 1, uint(len(server.spaces)))
+
+		if err != nil {
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+
+		gotID = true
+	}
+
+	switch r.Method {
+	case "GET":
+		w.Header().Set("Content-Type", "application/vnd.api+json")
+		if len(server.spaces) == 0 {
+			// Until a space is registered, behave as if the endpoint
+			// does not exist. This way we can simulate older MAAS
+			// servers that do not support spaces.
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+
+		if r.URL.Path == spacesURL {
+			var spaces []Space
+			for i := uint(1); i < server.nextSpace; i++ {
+				s, ok := server.spaces[i]
+				if ok {
+					spaces = append(spaces, s)
+				}
+			}
+			err = json.NewEncoder(w).Encode(spaces)
+		} else if gotID == false {
+			w.WriteHeader(http.StatusBadRequest)
+		} else {
+			err = json.NewEncoder(w).Encode(server.spaces[ID])
+		}
+		checkError(err)
+	case "POST":
+		//server.NewSpace(r.Body)
+	case "PUT":
+		//server.UpdateSpace(r.Body)
+	case "DELETE":
+		delete(server.spaces, ID)
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.WriteHeader(http.StatusBadRequest)
+	}
+}

=== added file 'testservice_subnets.go'
--- testservice_subnets.go	1970-01-01 00:00:00 +0000
+++ testservice_subnets.go	2015-11-27 13:51:56 +0000
@@ -0,0 +1,393 @@
+// Copyright 2015 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"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+func getSubnetsEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/subnets/", version)
+}
+
+// CreateSubnet is used to receive new subnets via the MAAS API
+type CreateSubnet struct {
+	DNSServers []string `json:"dns_servers"`
+	Name       string   `json:"name"`
+	Space      string   `json:"space"`
+	GatewayIP  string   `json:"gateway_ip"`
+	CIDR       string   `json:"cidr"`
+
+	// VLAN this subnet belongs to. Currently ignored.
+	// TODO: Defaults to the default VLAN
+	// for the provided fabric or defaults to the default VLAN
+	// in the default fabric.
+	VLAN *uint `json:"vlan"`
+
+	// Fabric for the subnet. Currently ignored.
+	// TODO: Defaults to the fabric the provided
+	// VLAN belongs to or defaults to the default fabric.
+	Fabric *uint `json:"fabric"`
+
+	// VID of the VLAN this subnet belongs to. Currently ignored.
+	// TODO: Only used when vlan
+	// is not provided. Picks the VLAN with this VID in the provided
+	// fabric or the default fabric if one is not given.
+	VID *uint `json:"vid"`
+
+	// This is used for updates (PUT) and is ignored by create (POST)
+	ID uint `json:"id"`
+}
+
+// Subnet is the MAAS API subnet representation
+type Subnet struct {
+	DNSServers []string `json:"dns_servers"`
+	Name       string   `json:"name"`
+	Space      string   `json:"space"`
+	VLAN       VLAN     `json:"vlan"`
+	GatewayIP  string   `json:"gateway_ip"`
+	CIDR       string   `json:"cidr"`
+
+	ResourceURI        string         `json:"resource_uri"`
+	ID                 uint           `json:"id"`
+	InUseIPAddresses   []IP           `json:"-"`
+	FixedAddressRanges []AddressRange `json:"-"`
+}
+
+// AddFixedAddressRange adds an AddressRange to the list of fixed address ranges
+// that subnet stores.
+func (server *TestServer) AddFixedAddressRange(subnetID uint, ar AddressRange) {
+	subnet := server.subnets[subnetID]
+	ar.startUint = IPFromString(ar.Start).UInt64()
+	ar.endUint = IPFromString(ar.End).UInt64()
+	subnet.FixedAddressRanges = append(subnet.FixedAddressRanges, ar)
+	server.subnets[subnetID] = subnet
+}
+
+// subnetsHandler handles requests for '/api/<version>/subnets/'.
+func subnetsHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	var err error
+	values, err := url.ParseQuery(r.URL.RawQuery)
+	checkError(err)
+	op := values.Get("op")
+	includeRangesString := strings.ToLower(values.Get("include_ranges"))
+	subnetsURLRE := regexp.MustCompile(`/subnets/(.+?)/`)
+	subnetsURLMatch := subnetsURLRE.FindStringSubmatch(r.URL.Path)
+	subnetsURL := getSubnetsEndpoint(server.version)
+
+	var ID uint
+	var gotID bool
+	if subnetsURLMatch != nil {
+		ID, err = NameOrIDToID(subnetsURLMatch[1], server.subnetNameToID, 1, uint(len(server.subnets)))
+
+		if err != nil {
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+
+		gotID = true
+	}
+
+	var includeRanges bool
+	switch includeRangesString {
+	case "true", "yes", "1":
+		includeRanges = true
+	}
+
+	switch r.Method {
+	case "GET":
+		w.Header().Set("Content-Type", "application/vnd.api+json")
+		if len(server.subnets) == 0 {
+			// Until a subnet is registered, behave as if the endpoint
+			// does not exist. This way we can simulate older MAAS
+			// servers that do not support subnets.
+			http.NotFoundHandler().ServeHTTP(w, r)
+			return
+		}
+
+		if r.URL.Path == subnetsURL {
+			var subnets []Subnet
+			for i := uint(1); i < server.nextSubnet; i++ {
+				s, ok := server.subnets[i]
+				if ok {
+					subnets = append(subnets, s)
+				}
+			}
+			PrettyJsonWriter(subnets, w)
+		} else if gotID == false {
+			w.WriteHeader(http.StatusBadRequest)
+		} else {
+			switch op {
+			case "unreserved_ip_ranges":
+				PrettyJsonWriter(server.subnetUnreservedIPRanges(server.subnets[ID]), w)
+			case "reserved_ip_ranges":
+				PrettyJsonWriter(server.subnetReservedIPRanges(server.subnets[ID]), w)
+			case "statistics":
+				PrettyJsonWriter(server.subnetStatistics(server.subnets[ID], includeRanges), w)
+			default:
+				PrettyJsonWriter(server.subnets[ID], w)
+			}
+		}
+		checkError(err)
+	case "POST":
+		server.NewSubnet(r.Body)
+	case "PUT":
+		server.UpdateSubnet(r.Body)
+	case "DELETE":
+		delete(server.subnets, ID)
+		w.WriteHeader(http.StatusOK)
+	default:
+		w.WriteHeader(http.StatusBadRequest)
+	}
+}
+
+type addressList []IP
+
+func (a addressList) Len() int           { return len(a) }
+func (a addressList) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a addressList) Less(i, j int) bool { return a[i].UInt64() < a[j].UInt64() }
+
+// AddressRange is used to generate reserved IP address range lists
+type AddressRange struct {
+	Start        string `json:"start"`
+	startUint    uint64
+	End          string `json:"end"`
+	endUint      uint64
+	Purpose      []string `json:"purpose,omitempty"`
+	NumAddresses uint     `json:"num_addresses"`
+}
+
+// AddressRangeList is a list of AddressRange
+type AddressRangeList struct {
+	ar []AddressRange
+}
+
+// Append appends a new AddressRange to an AddressRangeList
+func (ranges *AddressRangeList) Append(startIP, endIP IP) {
+	var i AddressRange
+	i.Start, i.End = startIP.String(), endIP.String()
+	i.startUint, i.endUint = startIP.UInt64(), endIP.UInt64()
+	i.NumAddresses = uint(1 + endIP.UInt64() - startIP.UInt64())
+	i.Purpose = startIP.Purpose
+	ranges.ar = append(ranges.ar, i)
+}
+
+func appendRangesToIPList(subnet Subnet, ipAddresses *[]IP) {
+	for _, r := range subnet.FixedAddressRanges {
+		for v := r.startUint; v <= r.endUint; v++ {
+			ip := IPFromInt64(v)
+			ip.Purpose = r.Purpose
+			*ipAddresses = append(*ipAddresses, ip)
+		}
+	}
+}
+
+func (server *TestServer) subnetUnreservedIPRanges(subnet Subnet) []AddressRange {
+	// Make a sorted copy of subnet.InUseIPAddresses
+	ipAddresses := make([]IP, len(subnet.InUseIPAddresses))
+	copy(ipAddresses, subnet.InUseIPAddresses)
+	appendRangesToIPList(subnet, &ipAddresses)
+	sort.Sort(addressList(ipAddresses))
+
+	// We need the first and last address in the subnet
+	var ranges AddressRangeList
+	var startIP, endIP, lastUsableIP IP
+
+	_, ipNet, err := net.ParseCIDR(subnet.CIDR)
+	checkError(err)
+	startIP = IPFromNetIP(ipNet.IP)
+	// Start with the lowest usable address in the range, which is 1 above
+	// what net.ParseCIDR will give back.
+	startIP.SetUInt64(startIP.UInt64() + 1)
+
+	ones, bits := ipNet.Mask.Size()
+	set := ^((^uint64(0)) << uint(bits-ones))
+
+	// The last usable address is one below the broadcast address, which is
+	// what you get by bitwise ORing 'set' with any IP address in the subnet.
+	lastUsableIP.SetUInt64((startIP.UInt64() | set) - 1)
+
+	for _, endIP = range ipAddresses {
+		end := endIP.UInt64()
+
+		if endIP.UInt64() == startIP.UInt64() {
+			if endIP.UInt64() != lastUsableIP.UInt64() {
+				startIP.SetUInt64(end + 1)
+			}
+			continue
+		}
+
+		if end == lastUsableIP.UInt64() {
+			continue
+		}
+
+		ranges.Append(startIP, IPFromInt64(end-1))
+		startIP.SetUInt64(end + 1)
+	}
+
+	if startIP.UInt64() != lastUsableIP.UInt64() {
+		ranges.Append(startIP, lastUsableIP)
+	}
+
+	return ranges.ar
+}
+
+func (server *TestServer) subnetReservedIPRanges(subnet Subnet) []AddressRange {
+	var ranges AddressRangeList
+	var startIP, thisIP IP
+
+	// Make a sorted copy of subnet.InUseIPAddresses
+	ipAddresses := make([]IP, len(subnet.InUseIPAddresses))
+	copy(ipAddresses, subnet.InUseIPAddresses)
+	appendRangesToIPList(subnet, &ipAddresses)
+	sort.Sort(addressList(ipAddresses))
+	startIP = ipAddresses[0]
+	lastIP := ipAddresses[0]
+
+	if len(ipAddresses) == 0 {
+		return ranges.ar
+	}
+
+	for _, thisIP = range ipAddresses {
+		var purposeMissmatch bool
+		for i, p := range thisIP.Purpose {
+			if startIP.Purpose[i] != p {
+				purposeMissmatch = true
+			}
+		}
+		if (thisIP.UInt64() != lastIP.UInt64() && thisIP.UInt64() != lastIP.UInt64()+1) || purposeMissmatch {
+			ranges.Append(startIP, lastIP)
+			startIP = thisIP
+		}
+		lastIP = thisIP
+	}
+
+	if len(ranges.ar) == 0 || ranges.ar[len(ranges.ar)-1].endUint != lastIP.UInt64() {
+		ranges.Append(startIP, lastIP)
+	}
+
+	return ranges.ar
+}
+
+// SubnetStats holds statistics about a subnet
+type SubnetStats struct {
+	NumAvailable     uint           `json:"num_available"`
+	LargestAvailable uint           `json:"largest_available"`
+	NumUnavailable   uint           `json:"num_unavailable"`
+	TotalAddresses   uint           `json:"total_addresses"`
+	Usage            float32        `json:"usage"`
+	UsageString      string         `json:"usage_string"`
+	Ranges           []AddressRange `json:"ranges"`
+}
+
+func (server *TestServer) subnetStatistics(subnet Subnet, includeRanges bool) SubnetStats {
+	var stats SubnetStats
+	_, ipNet, err := net.ParseCIDR(subnet.CIDR)
+	checkError(err)
+
+	ones, bits := ipNet.Mask.Size()
+	stats.TotalAddresses = (1 << uint(bits-ones)) - 2
+	stats.NumUnavailable = uint(len(subnet.InUseIPAddresses))
+	stats.NumAvailable = stats.TotalAddresses - stats.NumUnavailable
+	stats.Usage = float32(stats.NumUnavailable) / float32(stats.TotalAddresses)
+	stats.UsageString = fmt.Sprintf("%0.1f%%", stats.Usage*100)
+
+	// Calculate stats.LargestAvailable - the largest contiguous block of IP addresses available
+	reserved := server.subnetUnreservedIPRanges(subnet)
+	for _, addressRange := range reserved {
+		if addressRange.NumAddresses > stats.LargestAvailable {
+			stats.LargestAvailable = addressRange.NumAddresses
+		}
+	}
+
+	if includeRanges {
+		stats.Ranges = reserved
+	}
+
+	return stats
+}
+
+func decodePostedSubnet(subnetJSON io.Reader) CreateSubnet {
+	var postedSubnet CreateSubnet
+	decoder := json.NewDecoder(subnetJSON)
+	err := decoder.Decode(&postedSubnet)
+	checkError(err)
+	if postedSubnet.DNSServers == nil {
+		postedSubnet.DNSServers = []string{}
+	}
+	return postedSubnet
+}
+
+// UpdateSubnet creates a subnet in the test server
+func (server *TestServer) UpdateSubnet(subnetJSON io.Reader) Subnet {
+	postedSubnet := decodePostedSubnet(subnetJSON)
+	updatedSubnet := subnetFromCreateSubnet(postedSubnet)
+	server.subnets[updatedSubnet.ID] = updatedSubnet
+	return updatedSubnet
+}
+
+// NewSubnet creates a subnet in the test server
+func (server *TestServer) NewSubnet(subnetJSON io.Reader) *Subnet {
+	postedSubnet := decodePostedSubnet(subnetJSON)
+	newSubnet := subnetFromCreateSubnet(postedSubnet)
+	newSubnet.ID = server.nextSubnet
+	server.subnets[server.nextSubnet] = newSubnet
+	server.subnetNameToID[newSubnet.Name] = newSubnet.ID
+
+	server.nextSubnet++
+	return &newSubnet
+}
+
+// NodeNetworkInterface represents a network interface attached to a node
+type NodeNetworkInterface struct {
+	Name  string        `json:"name"`
+	Links []NetworkLink `json:"links"`
+}
+
+// Node represents a node
+type Node struct {
+	SystemID   string                 `json:"system_id"`
+	Interfaces []NodeNetworkInterface `json:"interface_set"`
+}
+
+// NetworkLink represents a MAAS network link
+type NetworkLink struct {
+	ID     uint    `json:"id"`
+	Mode   string  `json:"mode"`
+	Subnet *Subnet `json:"subnet"`
+}
+
+// SetNodeNetworkLink records that the given node + interface are in subnet
+func (server *TestServer) SetNodeNetworkLink(SystemID string, nodeNetworkInterface NodeNetworkInterface) {
+	for i, ni := range server.nodeMetadata[SystemID].Interfaces {
+		if ni.Name == nodeNetworkInterface.Name {
+			server.nodeMetadata[SystemID].Interfaces[i] = nodeNetworkInterface
+			return
+		}
+	}
+	n := server.nodeMetadata[SystemID]
+	n.Interfaces = append(n.Interfaces, nodeNetworkInterface)
+	server.nodeMetadata[SystemID] = n
+}
+
+// subnetFromCreateSubnet creates a subnet in the test server
+func subnetFromCreateSubnet(postedSubnet CreateSubnet) Subnet {
+	var newSubnet Subnet
+	newSubnet.DNSServers = postedSubnet.DNSServers
+	newSubnet.Name = postedSubnet.Name
+	newSubnet.Space = postedSubnet.Space
+	//TODO: newSubnet.VLAN = server.postedSubnetVLAN
+	newSubnet.GatewayIP = postedSubnet.GatewayIP
+	newSubnet.CIDR = postedSubnet.CIDR
+	newSubnet.ID = postedSubnet.ID
+	return newSubnet
+}

=== modified file 'testservice_test.go'
--- testservice_test.go	2015-07-02 16:05:11 +0000
+++ testservice_test.go	2015-11-27 13:51:56 +0000
@@ -9,10 +9,13 @@
 	"encoding/json"
 	"fmt"
 	"io"
+	"math/rand"
 	"mime/multipart"
+	"net"
 	"net/http"
 	"net/url"
 	"sort"
+	"strconv"
 	"strings"
 
 	"gopkg.in/mgo.v2/bson"
@@ -603,6 +606,352 @@
 	c.Check(resp.StatusCode, Equals, http.StatusNotFound)
 }
 
+func defaultSubnet() CreateSubnet {
+	var s CreateSubnet
+	s.DNSServers = []string{"192.168.1.2"}
+	s.Name = "maas-eth0"
+	s.Space = "space-0"
+	s.GatewayIP = "192.168.1.1"
+	s.CIDR = "192.168.1.0/24"
+	s.ID = 1
+	return s
+}
+
+func (suite *TestServerSuite) subnetJSON(subnet CreateSubnet) *bytes.Buffer {
+	var out bytes.Buffer
+	err := json.NewEncoder(&out).Encode(subnet)
+	if err != nil {
+		panic(err)
+	}
+	return &out
+}
+
+func (suite *TestServerSuite) subnetURL(ID int) string {
+	return suite.subnetsURL() + strconv.Itoa(ID) + "/"
+}
+
+func (suite *TestServerSuite) subnetsURL() string {
+	return suite.server.Server.URL + getSubnetsEndpoint(suite.server.version)
+}
+
+func (suite *TestServerSuite) getSubnets(c *C) []Subnet {
+	resp, err := http.Get(suite.subnetsURL())
+
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusOK)
+
+	var subnets []Subnet
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&subnets)
+	c.Check(err, IsNil)
+	return subnets
+}
+
+func (suite *TestServerSuite) TestSubnetAdd(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	subnets := suite.getSubnets(c)
+	c.Check(subnets, HasLen, 1)
+	s := subnets[0]
+	c.Check(s.DNSServers, DeepEquals, []string{"192.168.1.2"})
+	c.Check(s.Name, Equals, "maas-eth0")
+	c.Check(s.Space, Equals, "space-0")
+	c.Check(s.VLAN.ID, Equals, uint(0))
+	c.Check(s.CIDR, Equals, "192.168.1.0/24")
+}
+
+func (suite *TestServerSuite) TestSubnetGet(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	subnet2 := defaultSubnet()
+	subnet2.Name = "maas-eth1"
+	subnet2.CIDR = "192.168.2.0/24"
+	suite.server.NewSubnet(suite.subnetJSON(subnet2))
+
+	subnets := suite.getSubnets(c)
+	c.Check(subnets, HasLen, 2)
+	c.Check(subnets[0].CIDR, Equals, "192.168.1.0/24")
+	c.Check(subnets[1].CIDR, Equals, "192.168.2.0/24")
+}
+
+func (suite *TestServerSuite) TestSubnetPut(c *C) {
+	subnet1 := defaultSubnet()
+	suite.server.NewSubnet(suite.subnetJSON(subnet1))
+
+	subnets := suite.getSubnets(c)
+	c.Check(subnets, HasLen, 1)
+	c.Check(subnets[0].DNSServers, DeepEquals, []string{"192.168.1.2"})
+
+	subnet1.DNSServers = []string{"192.168.1.2", "192.168.1.3"}
+	suite.server.UpdateSubnet(suite.subnetJSON(subnet1))
+
+	subnets = suite.getSubnets(c)
+	c.Check(subnets, HasLen, 1)
+	c.Check(subnets[0].DNSServers, DeepEquals, []string{"192.168.1.2", "192.168.1.3"})
+}
+
+func (suite *TestServerSuite) TestSubnetDelete(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	subnets := suite.getSubnets(c)
+	c.Check(subnets, HasLen, 1)
+	c.Check(subnets[0].DNSServers, DeepEquals, []string{"192.168.1.2"})
+
+	req, err := http.NewRequest("DELETE", suite.subnetURL(1), nil)
+	c.Check(err, IsNil)
+	resp, err := http.DefaultClient.Do(req)
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusOK)
+
+	resp, err = http.Get(suite.subnetsURL())
+	c.Check(err, IsNil)
+	c.Check(resp.StatusCode, Equals, http.StatusNotFound)
+}
+
+func (suite *TestServerSuite) reserveSomeAddresses() map[int]bool {
+	reserved := make(map[int]bool)
+	rand.Seed(6)
+
+	// Insert some random test data
+	for i := 0; i < 200; i++ {
+		r := rand.Intn(253) + 1
+		_, ok := reserved[r]
+		for ok == true {
+			r++
+			if r == 255 {
+				r = 1
+			}
+			_, ok = reserved[r]
+		}
+		reserved[r] = true
+		addr := fmt.Sprintf("192.168.1.%d", r)
+		suite.server.NewIPAddress(addr, "maas-eth0")
+	}
+
+	return reserved
+}
+
+func (suite *TestServerSuite) TestSubnetReservedIPRanges(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+	reserved := suite.reserveSomeAddresses()
+
+	// Fetch from the server
+	reservedIPRangeURL := suite.subnetURL(1) + "?op=reserved_ip_ranges"
+	resp, err := http.Get(reservedIPRangeURL)
+	c.Check(err, IsNil)
+
+	var reservedFromAPI []AddressRange
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&reservedFromAPI)
+	c.Check(err, IsNil)
+
+	// Check that anything in a reserved range was an address we allocated
+	// with NewIPAddress
+	for _, addressRange := range reservedFromAPI {
+		var start, end int
+		fmt.Sscanf(addressRange.Start, "192.168.1.%d", &start)
+		fmt.Sscanf(addressRange.End, "192.168.1.%d", &end)
+		c.Check(addressRange.NumAddresses, Equals, uint(1+end-start))
+		c.Check(start <= end, Equals, true)
+		c.Check(start < 255, Equals, true)
+		c.Check(end < 255, Equals, true)
+		for i := start; i <= end; i++ {
+			_, ok := reserved[int(i)]
+			c.Check(ok, Equals, true)
+			delete(reserved, int(i))
+		}
+	}
+	c.Check(reserved, HasLen, 0)
+}
+
+func (suite *TestServerSuite) TestSubnetUnreservedIPRanges(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+	reserved := suite.reserveSomeAddresses()
+	unreserved := make(map[int]bool)
+
+	// Fetch from the server
+	reservedIPRangeURL := suite.subnetURL(1) + "?op=unreserved_ip_ranges"
+	resp, err := http.Get(reservedIPRangeURL)
+	c.Check(err, IsNil)
+
+	var unreservedFromAPI []AddressRange
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&unreservedFromAPI)
+	c.Check(err, IsNil)
+
+	// Check that anything in an unreserved range wasn't an address we allocated
+	// with NewIPAddress
+	for _, addressRange := range unreservedFromAPI {
+		var start, end int
+		fmt.Sscanf(addressRange.Start, "192.168.1.%d", &start)
+		fmt.Sscanf(addressRange.End, "192.168.1.%d", &end)
+		c.Check(addressRange.NumAddresses, Equals, uint(1+end-start))
+		c.Check(start <= end, Equals, true)
+		c.Check(start < 255, Equals, true)
+		c.Check(end < 255, Equals, true)
+		for i := start; i <= end; i++ {
+			_, ok := reserved[int(i)]
+			c.Check(ok, Equals, false)
+			unreserved[int(i)] = true
+		}
+	}
+	for i := 1; i < 255; i++ {
+		_, r := reserved[i]
+		_, u := unreserved[i]
+		if (r || u) == false {
+			fmt.Println(i, r, u)
+		}
+		c.Check(r || u, Equals, true)
+	}
+	c.Check(len(reserved)+len(unreserved), Equals, 254)
+}
+
+func (suite *TestServerSuite) TestSubnetReserveRange(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+	suite.server.NewIPAddress("192.168.1.10", "maas-eth0")
+
+	var ar AddressRange
+	ar.Start = "192.168.1.100"
+	ar.End = "192.168.1.200"
+	ar.Purpose = []string{"dynamic"}
+
+	suite.server.AddFixedAddressRange(1, ar)
+
+	// Fetch from the server
+	reservedIPRangeURL := suite.subnetURL(1) + "?op=reserved_ip_ranges"
+	resp, err := http.Get(reservedIPRangeURL)
+	c.Check(err, IsNil)
+
+	var reservedFromAPI []AddressRange
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&reservedFromAPI)
+	c.Check(err, IsNil)
+
+	// Check that the address ranges we got back were as expected
+	addressRange := reservedFromAPI[0]
+	c.Check(addressRange.Start, Equals, "192.168.1.10")
+	c.Check(addressRange.End, Equals, "192.168.1.10")
+	c.Check(addressRange.NumAddresses, Equals, uint(1))
+	c.Check(addressRange.Purpose[0], Equals, "assigned-ip")
+	c.Check(addressRange.Purpose, HasLen, 1)
+
+	addressRange = reservedFromAPI[1]
+	c.Check(addressRange.Start, Equals, "192.168.1.100")
+	c.Check(addressRange.End, Equals, "192.168.1.200")
+	c.Check(addressRange.NumAddresses, Equals, uint(101))
+	c.Check(addressRange.Purpose[0], Equals, "dynamic")
+	c.Check(addressRange.Purpose, HasLen, 1)
+}
+
+func (suite *TestServerSuite) getSubnetStats(c *C, subnetID int) SubnetStats {
+	URL := suite.subnetURL(1) + "?op=statistics"
+	resp, err := http.Get(URL)
+	c.Check(err, IsNil)
+
+	var s SubnetStats
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&s)
+	c.Check(err, IsNil)
+	return s
+}
+
+func (suite *TestServerSuite) TestSubnetStats(c *C) {
+	suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	stats := suite.getSubnetStats(c, 1)
+	// There are 254 usable addresses in a class C subnet, so these
+	// stats are fixed
+	expected := SubnetStats{
+		NumAvailable:     254,
+		LargestAvailable: 254,
+		NumUnavailable:   0,
+		TotalAddresses:   254,
+		Usage:            0,
+		UsageString:      "0.0%",
+		Ranges:           nil,
+	}
+	c.Check(stats, DeepEquals, expected)
+
+	suite.reserveSomeAddresses()
+	stats = suite.getSubnetStats(c, 1)
+	// We have reserved 200 addresses so parts of these
+	// stats are fixed.
+	expected = SubnetStats{
+		NumAvailable:   54,
+		NumUnavailable: 200,
+		TotalAddresses: 254,
+		Usage:          0.787401556968689,
+		UsageString:    "78.7%",
+		Ranges:         nil,
+	}
+
+	reserved := suite.server.subnetUnreservedIPRanges(suite.server.subnets[1])
+	var largestAvailable uint
+	for _, addressRange := range reserved {
+		if addressRange.NumAddresses > largestAvailable {
+			largestAvailable = addressRange.NumAddresses
+		}
+	}
+
+	expected.LargestAvailable = largestAvailable
+	c.Check(stats, DeepEquals, expected)
+}
+
+func (suite *TestServerSuite) TestSubnetsInNodes(c *C) {
+	// Create a subnet
+	subnet := suite.server.NewSubnet(suite.subnetJSON(defaultSubnet()))
+
+	// Create a node
+	var node Node
+	node.SystemID = "node-89d832ca-8877-11e5-b5a5-00163e86022b"
+	suite.server.NewNode(fmt.Sprintf(`{"system_id": "%s"}`, "node-89d832ca-8877-11e5-b5a5-00163e86022b"))
+
+	// Put the node in the subnet
+	var nni NodeNetworkInterface
+	nni.Name = "eth0"
+	nni.Links = append(nni.Links, NetworkLink{uint(1), "auto", subnet})
+	suite.server.SetNodeNetworkLink(node.SystemID, nni)
+
+	// Fetch the node details
+	URL := suite.server.Server.URL + getNodesEndpoint(suite.server.version) + node.SystemID + "/"
+	resp, err := http.Get(URL)
+	c.Check(err, IsNil)
+
+	var n Node
+	decoder := json.NewDecoder(resp.Body)
+	err = decoder.Decode(&n)
+	c.Check(err, IsNil)
+	c.Check(n.SystemID, Equals, node.SystemID)
+	c.Check(n.Interfaces, HasLen, 1)
+	i := n.Interfaces[0]
+	c.Check(i.Name, Equals, "eth0")
+	c.Check(i.Links, HasLen, 1)
+	c.Check(i.Links[0].ID, Equals, uint(1))
+	c.Check(i.Links[0].Subnet.Name, Equals, "maas-eth0")
+}
+
+type IPSuite struct {
+}
+
+var _ = Suite(&IPSuite{})
+
+func (suite *IPSuite) TestIPFromNetIP(c *C) {
+	ip := IPFromNetIP(net.ParseIP("1.2.3.4"))
+	c.Check(ip.String(), Equals, "1.2.3.4")
+}
+
+func (suite *IPSuite) TestIPUInt64(c *C) {
+	ip := IPFromNetIP(net.ParseIP("1.2.3.4"))
+	v := ip.UInt64()
+	c.Check(v, Equals, uint64(0x01020304))
+}
+
+func (suite *IPSuite) TestIPSetUInt64(c *C) {
+	var ip IP
+	ip.SetUInt64(0x01020304)
+	c.Check(ip.String(), Equals, "1.2.3.4")
+}
+
 // TestMAASObjectSuite validates that the object created by
 // NewTestMAAS can be used by the gomaasapi library as if it were a real
 // MAAS server.
@@ -612,16 +961,16 @@
 
 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) SetUpSuite(c *C) {
+	suite.TestMAASObject = NewTestMAAS("1.0")
+}
+
+func (suite *TestMAASObjectSuite) TearDownSuite(c *C) {
+	suite.TestMAASObject.Close()
+}
+
+func (suite *TestMAASObjectSuite) TearDownTest(c *C) {
+	suite.TestMAASObject.TestServer.Clear()
 }
 
 func (suite *TestMAASObjectSuite) TestListNodes(c *C) {
@@ -1019,6 +1368,8 @@
 		switch capName {
 		case "networks-management":
 		case "static-ipaddresses":
+		case "devices-management":
+		case "network-deployment-ubuntu":
 		default:
 			c.Fatalf("unknown capability %q", capName)
 		}

=== added file 'testservice_utils.go'
--- testservice_utils.go	1970-01-01 00:00:00 +0000
+++ testservice_utils.go	2015-11-27 13:51:56 +0000
@@ -0,0 +1,119 @@
+// Copyright 2015 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"net"
+	"net/http"
+	"strconv"
+)
+
+// NameOrIDToID takes a string that contains eiter an integer ID or the
+// name of a thing. It returns the integer ID contained or mapped to or panics.
+func NameOrIDToID(v string, nameToID map[string]uint, minID, maxID uint) (ID uint, err error) {
+	ID, ok := nameToID[v]
+	if !ok {
+		intID, err := strconv.Atoi(v)
+		if err != nil {
+			return 0, err
+		}
+		ID = uint(intID)
+	}
+
+	if ID < minID || ID > maxID {
+		return 0, errors.New("ID out of range")
+	}
+
+	return ID, nil
+}
+
+// IP is an enhanced net.IP
+type IP struct {
+	netIP   net.IP
+	Purpose []string
+}
+
+// IPFromNetIP creates a IP from a net.IP.
+func IPFromNetIP(netIP net.IP) IP {
+	var ip IP
+	ip.netIP = netIP
+	return ip
+}
+
+// IPFromString creates a new IP from a string IP address representation
+func IPFromString(v string) IP {
+	return IPFromNetIP(net.ParseIP(v))
+}
+
+// IPFromInt64 creates a new IP from a uint64 IP address representation
+func IPFromInt64(v uint64) IP {
+	var ip IP
+	ip.SetUInt64(v)
+	return ip
+}
+
+// To4 converts the IPv4 address ip to a 4-byte representation. If ip is not
+// an IPv4 address, To4 returns nil.
+func (ip IP) To4() net.IP {
+	return ip.netIP.To4()
+}
+
+// To16 converts the IP address ip to a 16-byte representation. If ip is not
+// an IP address (it is the wrong length), To16 returns nil.
+func (ip IP) To16() net.IP {
+	return ip.netIP.To16()
+}
+
+func (ip IP) String() string {
+	return ip.netIP.String()
+}
+
+// UInt64 returns a uint64 holding the IP address
+func (ip IP) UInt64() uint64 {
+	if len(ip.netIP) == 0 {
+		return uint64(0)
+	}
+
+	if ip.To4() != nil {
+		return uint64(binary.BigEndian.Uint32([]byte(ip.To4())))
+	}
+
+	return binary.BigEndian.Uint64([]byte(ip.To16()))
+}
+
+// SetUInt64 sets the IP value to v
+func (ip *IP) SetUInt64(v uint64) {
+	if len(ip.netIP) == 0 {
+		// If we don't have allocated storage make an educated guess
+		// at if the address we received is an IPv4 or IPv6 address.
+		if v == (v & 0x00000000ffffFFFF) {
+			// Guessing IPv4
+			ip.netIP = net.ParseIP("0.0.0.0")
+		} else {
+			ip.netIP = net.ParseIP("2001:4860:0:2001::68")
+		}
+	}
+
+	bb := new(bytes.Buffer)
+	var first int
+	if ip.To4() != nil {
+		binary.Write(bb, binary.BigEndian, uint32(v))
+		first = len(ip.netIP) - 4
+	} else {
+		binary.Write(bb, binary.BigEndian, v)
+	}
+	copy(ip.netIP[first:], bb.Bytes())
+}
+
+func PrettyJsonWriter(thing interface{}, w http.ResponseWriter) {
+	var out bytes.Buffer
+	b, err := json.MarshalIndent(thing, "", "  ")
+	checkError(err)
+	out.Write(b)
+	out.WriteTo(w)
+}

=== added file 'testservice_vlan.go'
--- testservice_vlan.go	1970-01-01 00:00:00 +0000
+++ testservice_vlan.go	2015-11-27 13:51:56 +0000
@@ -0,0 +1,33 @@
+// Copyright 2015 Canonical Ltd.  This software is licensed under the
+// GNU Lesser General Public License version 3 (see the file COPYING).
+
+package gomaasapi
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func getVLANsEndpoint(version string) string {
+	return fmt.Sprintf("/api/%s/vlans/", version)
+}
+
+// VLAN is the MAAS API VLAN representation
+type VLAN struct {
+	Name   string `json:"name"`
+	Fabric string `json:"fabric"`
+	VID    uint   `json:"vid"`
+
+	ResourceURI string `json:"resource_uri"`
+	ID          uint   `json:"id"`
+}
+
+// PostedVLAN is the MAAS API posted VLAN representation
+type PostedVLAN struct {
+	Name string `json:"name"`
+	VID  uint   `json:"vid"`
+}
+
+func vlansHandler(server *TestServer, w http.ResponseWriter, r *http.Request) {
+	//TODO
+}