Second phase of nova testing service: HTTP API.

testservices/novaservice/service.go

 // Nova double testing service - internal direct API implementation
 
 package novaservice
 
 import (
         "fmt"
         "launchpad.net/goose/nova"
         "strings"
 )
 
 // Nova implements a OpenStack Nova testing service and
 // contains the service double's internal state.
 type Nova struct {
         flavors      map[string]nova.FlavorDetail
         servers      map[string]nova.ServerDetail
         groups       map[int]nova.SecurityGroup
         rules        map[int]nova.SecurityGroupRule
         floatingIPs  map[int]nova.FloatingIP
         serverGroups map[string][]int
         serverIPs    map[string][]int
         hostname     string
-        baseURL      string
+        versionPath  string
         token        string
+        tenantId     string
+}
+
+// endpoint returns either a versioned or non-versioned service
+// endpoint URL from the given path.
+func (n *Nova) endpoint(version bool, path string) string {
+        ep := n.hostname
+        if version {
+                ep += n.versionPath + "/"
+        }
+        ep += n.tenantId + "/" + strings.TrimLeft(path, "/")
+        return ep
 }
 
 // New creates an instance of the Nova object, given the parameters.
-func New(hostname, baseURL, token string) *Nova {
+func New(hostname, versionPath, token, tenantId string) *Nova {
+        if !strings.HasSuffix(hostname, "/") {
+                hostname += "/"
+        }
         nova := &Nova{
                 flavors:      make(map[string]nova.FlavorDetail),
                 servers:      make(map[string]nova.ServerDetail),
                 groups:       make(map[int]nova.SecurityGroup),
                 rules:        make(map[int]nova.SecurityGroupRule),
                 floatingIPs:  make(map[int]nova.FloatingIP),
                 serverGroups: make(map[string][]int),
                 serverIPs:    make(map[string][]int),
                 hostname:     hostname,
-                baseURL:      baseURL,
+                versionPath:  versionPath,
                 token:        token,
+                tenantId:     tenantId,
         }
         return nova
 }
 
 // buildFlavorLinks populates the Links field of the passed
 // FlavorDetail as needed by OpenStack HTTP API. Call this
 // before addFlavor().
 func (n *Nova) buildFlavorLinks(flavor *nova.FlavorDetail) {
-        ep := n.hostname
-        ver := strings.TrimLeft(n.baseURL, "/")
-        url := n.token + "/flavors/" + flavor.Id
+        url := "/flavors/" + flavor.Id
         flavor.Links = []nova.Link{
-                nova.Link{Href: ep + ver + url, Rel: "self"},
-                nova.Link{Href: ep + url, Rel: "bookmark"},
+                nova.Link{Href: n.endpoint(true, url), Rel: "self"},
+                nova.Link{Href: n.endpoint(false, url), Rel: "bookmark"},
         }
 }
 
 // addFlavor creates a new flavor.
 func (n *Nova) addFlavor(flavor nova.FlavorDetail) error {
         if _, err := n.flavor(flavor.Id); err == nil {
                 return fmt.Errorf("a flavor with id %q already exists", flavor.Id)
         }
         n.flavors[flavor.Id] = flavor
         return nil
@@ skipping 49 matching lines @@
                 return err
         }
         delete(n.flavors, flavorId)
         return nil
 }
 
 // buildServerLinks populates the Links field of the passed
 // ServerDetail as needed by OpenStack HTTP API. Call this
 // before addServer().
 func (n *Nova) buildServerLinks(server *nova.ServerDetail) {
-        ep := n.hostname
-        ver := strings.TrimLeft(n.baseURL, "/")
-        url := n.token + "/servers/" + server.Id
+        url := "/servers/" + server.Id
         server.Links = []nova.Link{
-                nova.Link{Href: ep + ver + url, Rel: "self"},
-                nova.Link{Href: ep + url, Rel: "bookmark"},
+                nova.Link{Href: n.endpoint(true, url), Rel: "self"},
+                nova.Link{Href: n.endpoint(false, url), Rel: "bookmark"},
         }
 }
 
 // addServer creates a new server.
 func (n *Nova) addServer(server nova.ServerDetail) error {
         if _, err := n.server(server.Id); err == nil {
                 return fmt.Errorf("a server with id %q already exists", server.Id)
         }
         n.servers[server.Id] = server
         return nil
@@ skipping 355 matching lines @@
                         break
                 }
         }
         if idx == -1 {
                 return fmt.Errorf("server %q does not have floating IP %d", serverId, ipId)
         }
         fips = append(fips[:idx], fips[idx+1:]...)
         n.serverIPs[serverId] = fips
         return nil
 }