fix test

Author: James Fisher

openstack/imageservice/v2/fixtures.go

@@ -13,7 +13,6 @@ import (
 
 func HandleImageCreationSuccessfully(t *testing.T) {
 	th.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
-		// TODO
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
 		th.TestJSONRequest(t, r, `{

openstack/imageservice/v2/requests.go

@@ -21,77 +21,89 @@ func Create(client *gophercloud.ServiceClient, opts CreateOptsBuilder) CreateRes
 		res.Err = err
 		return res
 	}
-	response, err := client.Post(createURL(client), body, &res.Body, nil)
+	_, err = client.Post(createURL(client), body, &res.Body, &gophercloud.RequestOpts{OkCodes: []int{200}})
 	// TODO check response..?
 	return res
 }
 
 // CreateOptsBuilder describes struct types that can be accepted by the Create call.
 // The CreateOpts struct in this package does.
 type CreateOptsBuilder interface {
-	// Returns value that implements json.Marshaler
+	// Returns value that can be passed to json.Marshal
 	ToImageCreateMap() (map[string]interface{}, error)
 }
 
 // implements CreateOptsBuilder
 type CreateOpts struct {
 	// Name [required] is the name of the new image.
-	Name string
+	Name *string
 
 	// Id [optional] is the the image ID.
-	Id string
+	Id *string
 
 	// Visibility [optional] defines who can see/use the image.
-	Visibility ImageVisibility
+	Visibility *ImageVisibility
 
 	// Tags [optional] is a set of image tags.
 	Tags []string
 
 	// ContainerFormat [optional] is the format of the
 	// container. Valid values are ami, ari, aki, bare, and ovf.
-	ContainerFormat string
+	ContainerFormat *string
 
 	// DiskFormat [optional] is the format of the disk. If set,
 	// valid values are ami, ari, aki, vhd, vmdk, raw, qcow2, vdi,
 	// and iso.
-	DiskFormat string
+	DiskFormat *string
 
 	// MinDiskGigabytes [optional] is the amount of disk space in
 	// GB that is required to boot the image.
-	MinDiskGigabytes int
+	MinDiskGigabytes *int
 
 	// MinRamMegabytes [optional] is the amount of RAM in MB that
 	// is required to boot the image.
-	MinRamMegabytes int
+	MinRamMegabytes *int
 
 	// protected [optional] is whether the image is not deletable.
-	Protected bool
+	Protected *bool
 
 	// properties [optional] is a set of properties, if any, that
 	// are associated with the image.
 	Properties map[string]string
 }
 
-func setIfNotNil(m map[string]interface{}, k string, v interface{}) {
-	if v != nil {
-		m[k] = v
-	}
-}
-
 // ToImageCreateMap assembles a request body based on the contents of
 // a CreateOpts.
 func (opts CreateOpts) ToImageCreateMap() (map[string]interface{}, error) {
 	body := map[string]interface{}{}
 	body["name"] = opts.Name
-	setIfNotNil(body, "id", opts.Id)
-	setIfNotNil(body, "visibility", opts.Visibility)
-	setIfNotNil(body, "tags", opts.Tags)
-	setIfNotNil(body, "container_format", opts.ContainerFormat)
-	setIfNotNil(body, "disk_format", opts.DiskFormat)
-	setIfNotNil(body, "min_disk", opts.MinDiskGigabytes)
-	setIfNotNil(body, "min_ram", opts.MinRamMegabytes)
-	setIfNotNil(body, "protected", opts.Protected)
-	setIfNotNil(body, "properties", opts.Properties)
+	if opts.Id != nil {
+		body["id"] = opts.Id
+	}
+	if opts.Visibility != nil {
+		body["visibility"] = opts.Visibility
+	}
+	if opts.Tags != nil {
+		body["tags"] = opts.Tags
+	}
+	if opts.ContainerFormat != nil {
+		body["container_format"] = opts.ContainerFormat
+	}
+	if opts.DiskFormat != nil {
+		body["disk_format"] = opts.DiskFormat
+	}
+	if opts.MinDiskGigabytes != nil {
+		body["min_disk"] = opts.MinDiskGigabytes
+	}
+	if opts.MinRamMegabytes != nil {
+		body["min_ram"] = opts.MinRamMegabytes
+	}
+	if opts.Protected != nil {
+		body["protected"] = opts.Protected
+	}
+	if opts.Properties != nil {
+		body["properties"] = opts.Properties
+	}
 	return body, nil
 }
 

openstack/imageservice/v2/requests_test.go

@@ -16,17 +16,21 @@ func TestCreateImage(t *testing.T) {
 
 	HandleImageCreationSuccessfully(t)
 
+	id := "e7db3b45-8db7-47ad-8109-3fb55c2c24fd"
+	name := "Ubuntu 12.10"
+
 	actualImage, err := Create(fakeclient.ServiceClient(), CreateOpts{
-		Name: "Ubuntu 12.10",
-		Id: "e7db3b45-8db7-47ad-8109-3fb55c2c24fd",
+		Id: &id,
+		Name: &name,
 		Tags: []string{"ubuntu", "quantal"},
 	}).Extract()
 
 	th.AssertNoErr(t, err)
 
 	expectedImage := Image{
-		Name: "Ubuntu 12.10",
 		Id: "e7db3b45-8db7-47ad-8109-3fb55c2c24fd",
+		Name: "Ubuntu 12.10",
+		Status: ImageStatusQueued,
 		Tags: []string{"ubuntu", "quantal"},
 	}
 

openstack/imageservice/v2/results.go

@@ -1,6 +1,9 @@
 package v2
 
 import (
+	"errors"
+	"fmt"
+	
 	"github.com/rackspace/gophercloud"
 	//"github.com/rackspace/gophercloud/pagination"
 
@@ -10,13 +13,13 @@ import (
 // does not include the literal image data; just metadata.
 // returned by listing images, and by fetching a specific image.
 type Image struct {
-	Id string `mapstructure:"id"`
+	Id string
 
-	Name string `mapstructure:"name"`
+	Name string
 
-	Status ImageStatus `mapstructure:"status"`
+	Status ImageStatus
 
-	Tags []string `mapstructure:"tags"`
+	Tags []string
 
 	ContainerFormat string `mapstructure:"container_format"`
 	DiskFormat string `mapstructure:"disk_format"`
@@ -46,12 +49,102 @@ type CreateResult struct {
 	gophercloud.ErrResult
 }
 
-// The response to `POST /images` follows the same schema as `GET /images/:id`.
+func asString(any interface{}) (string, error) {
+	if str, ok := any.(string); ok {
+		return str, nil
+	} else {
+		return "", errors.New(fmt.Sprintf("expected string value, but found: %#v", any))
+	}
+}
+
+func extractStringAtKey(m map[string]interface{}, k string) (string, error) {
+	if any, ok := m[k]; ok {
+		return asString(any)
+	} else {
+		return "", errors.New(fmt.Sprintf("expected key \"%s\" in map, but this key is not present", k))
+	}
+}
+
+func extractStringSliceAtKey(m map[string]interface{}, k string) ([]string, error) {
+	if any, ok := m[k]; ok {
+		if slice, ok := any.([]interface{}); ok {
+			res := make([]string, len(slice))
+			for k, v := range slice {
+				var err error
+				if res[k], err = asString(v); err != nil {
+					return nil, err
+				}
+			}
+			return res, nil
+		} else {
+			return nil, errors.New(fmt.Sprintf("expected slice as \"%s\" value, but found: %#v", k, any))
+		}
+	} else {
+		return nil, errors.New(fmt.Sprintf("expected key \"%s\" in map, but this key is not present", k))
+	}
+}
+
+func stringToImageStatus(s string) (ImageStatus, error) {
+	if s == "queued" {
+		return ImageStatusQueued, nil
+	} else if s == "active" {
+		return ImageStatusActive, nil
+	} else {
+		return "", errors.New(fmt.Sprintf("expected \"active\" as image status, but found: \"%s\"", s))
+	}
+}
+
+func extractImageStatusAtKey(m map[string]interface{}, k string) (ImageStatus, error) {
+	if any, ok := m[k]; ok {
+		if str, ok := any.(string); ok {
+			return stringToImageStatus(str)
+		} else {
+			return "", errors.New(fmt.Sprintf("expected string as \"%s\" value, but found: %#v", k, any))
+		}
+	} else {
+		return "", errors.New(fmt.Sprintf("expected key \"%s\" in map, but this key is not present", k))
+	}
+}
+
 func extractImage(res gophercloud.ErrResult) (*Image, error) {
 	if res.Err != nil {
 		return nil, res.Err
 	}
 
+	body, ok := res.Body.(map[string]interface{})
+	if !ok {
+		return nil, errors.New(fmt.Sprintf("expected map as result body, but found: %#v", res.Body))
+	}
+	
+	var image Image
+
+	var err error
+	
+	if image.Id, err = extractStringAtKey(body, "id"); err != nil {
+		return nil, err
+	}
+
+	if image.Name, err = extractStringAtKey(body, "name"); err != nil {
+		return nil, err
+	}
+
+	if image.Status, err = extractImageStatusAtKey(body, "status"); err != nil {
+		return nil, err
+	}
+
+	if image.Tags, err = extractStringSliceAtKey(body, "tags"); err != nil {
+		return nil, err
+	}
+
+	return &image, nil
+}
+
+// The response to `POST /images` follows the same schema as `GET /images/:id`.
+func extractImageOld(res gophercloud.ErrResult) (*Image, error) {
+	if res.Err != nil {
+		return nil, res.Err
+	}
+
 	var image Image
 
 	err := mapstructure.Decode(res.Body, &image)

openstack/imageservice/v2/types.go

@@ -2,6 +2,7 @@ package v2
 
 type ImageStatus string
 const (
+	ImageStatusQueued ImageStatus = "queued"
 	ImageStatusActive ImageStatus = "active"
 	// TODO
 )