func TestCreateContainer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleCreateContainerSuccessfully(t) options := CreateOpts{ContentType: "application/json", Metadata: map[string]string{"foo": "bar"}} res := Create(fake.ServiceClient(), "testContainer", options) c, err := res.Extract() th.CheckNoErr(t, err) th.CheckEquals(t, "bar", res.Header["X-Container-Meta-Foo"][0]) th.CheckEquals(t, "1234567", c.TransID) }
func TestAuthenticatedClientV2(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/v2.0/tokens", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, ` { "access": { "token": { "id": "01234567890", "expires": "2014-10-01T10:00:00.000000Z" }, "serviceCatalog": [] } } `) }) options := gophercloud.AuthOptions{ Username: "******", APIKey: "09876543210", IdentityEndpoint: th.Endpoint() + "v2.0/", } client, err := AuthenticatedClient(options) th.AssertNoErr(t, err) th.CheckEquals(t, "01234567890", client.TokenID) }
func TestV3EndpointNone(t *testing.T) { _, err := V3EndpointURL(&catalog3, gophercloud.EndpointOpts{ Type: "nope", Availability: gophercloud.AvailabilityPublic, }) th.CheckEquals(t, ErrEndpointNotFound{}.Error(), err.Error()) }
func TestListImageDetails(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/images/detail", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", client.TokenID) w.Header().Add("Content-Type", "application/json") r.ParseForm() marker := r.Form.Get("marker") switch marker { case "": fmt.Fprintf(w, ListOutput) case "e19a734c-c7e6-443a-830c-242209c4d65d": fmt.Fprintf(w, `{ "images": [] }`) default: t.Fatalf("Unexpected marker: [%s]", marker) } }) count := 0 err := ListDetail(client.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractImages(page) th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedImageSlice, actual) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, 1, count) }
func TestListURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-keypairs", listURL(c)) }
func TestDeleteURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-keypairs/wat", deleteURL(c, "wat")) }
func TestCreateURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-volumes_boot", createURL(c)) }
func TestV2EndpointNone(t *testing.T) { _, err := V2EndpointURL(&catalog2, gophercloud.EndpointOpts{ Type: "nope", Availability: gophercloud.AvailabilityPublic, }) th.CheckEquals(t, gophercloud.ErrEndpointNotFound, err) }
func tokenPostErr(t *testing.T, options gophercloud.AuthOptions, expectedErr error) { th.SetupHTTP() defer th.TeardownHTTP() HandleTokenPost(t, "") actualErr := Create(client.ServiceClient(), AuthOptions{options}).Err th.CheckEquals(t, expectedErr, actualErr) }
func TestListURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0" th.CheckEquals(t, c.Endpoint+"servers/"+serverId+"/os-volume_attachments", listURL(c, serverId)) }
func TestExtractList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() servers.HandleServerListSuccessfully(t) pages := 0 err := servers.List(client.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) { pages++ config, err := ExtractDiskConfig(page, 0) th.AssertNoErr(t, err) th.CheckEquals(t, Manual, *config) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, pages, 1) }
func TestDeleteURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0" aId := "a26887c6-c47b-4654-abb5-dfadf7d3f804" th.CheckEquals(t, c.Endpoint+"servers/"+serverId+"/os-volume_attachments/"+aId, deleteURL(c, serverId, aId)) }
func TestUserAgent(t *testing.T) { p := &ProviderClient{} p.UserAgent.Prepend("custom-user-agent/2.4.0") expected := "custom-user-agent/2.4.0 gophercloud/1.0.0" actual := p.UserAgent.Join() th.CheckEquals(t, expected, actual) p.UserAgent.Prepend("another-custom-user-agent/0.3.0", "a-third-ua/5.9.0") expected = "another-custom-user-agent/0.3.0 a-third-ua/5.9.0 custom-user-agent/2.4.0 gophercloud/1.0.0" actual = p.UserAgent.Join() th.CheckEquals(t, expected, actual) p.UserAgent = UserAgent{} expected = "gophercloud/1.0.0" actual = p.UserAgent.Join() th.CheckEquals(t, expected, actual) }
func TestDownloadObject(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleDownloadObjectSuccessfully(t) content, err := Download(fake.ServiceClient(), "testContainer", "testObject", nil).ExtractContent() th.AssertNoErr(t, err) th.CheckEquals(t, string(content), "Successful download with Gophercloud") }
func TestExtractGet(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() servers.HandleServerGetSuccessfully(t) config, err := ExtractGet(servers.Get(client.ServiceClient(), "1234asdf")) th.AssertNoErr(t, err) th.CheckEquals(t, Manual, *config) }
func TestV3EndpointBadAvailability(t *testing.T) { _, err := V3EndpointURL(&catalog3, gophercloud.EndpointOpts{ Type: "same", Name: "same", Region: "same", Availability: "wat", }) th.CheckEquals(t, "Unexpected availability in endpoint query: wat", err.Error()) }
func TestUpdate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockUpdateResponse(t) options := UpdateOpts{Name: "vol-002"} v, err := Update(client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract() th.AssertNoErr(t, err) th.CheckEquals(t, "vol-002", v.Name) }
func TestDownloadExtraction(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleDownloadObjectSuccessfully(t) response := Download(fake.ServiceClient(), "testContainer", "testObject", nil) // Check []byte extraction bytes, err := response.ExtractContent() th.AssertNoErr(t, err) th.CheckEquals(t, "Successful download with Gophercloud", string(bytes)) }
func TestExtractUpdate(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() servers.HandleServerUpdateSuccessfully(t) r := servers.Update(client.ServiceClient(), "1234asdf", servers.UpdateOpts{ Name: "new-name", }) config, err := ExtractUpdate(r) th.AssertNoErr(t, err) th.CheckEquals(t, Manual, *config) }
func TestDownloadReader(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleDownloadObjectSuccessfully(t) response := Download(fake.ServiceClient(), "testContainer", "testObject", nil) defer response.Body.Close() // Check reader buf := bytes.NewBuffer(make([]byte, 0)) io.CopyN(buf, response.Body, 10) th.CheckEquals(t, "Successful", string(buf.Bytes())) }
func TestExtractRebuild(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() servers.HandleRebuildSuccessfully(t, servers.SingleServerBody) r := servers.Rebuild(client.ServiceClient(), "1234asdf", servers.RebuildOpts{ Name: "new-name", AdminPass: "******", ImageID: "http://104.130.131.164:8774/fcad67a6189847c4aecfa3c81a05783b/images/f90f6034-2570-4974-8351-6b49732ef2eb", AccessIPv4: "1.2.3.4", }) config, err := ExtractRebuild(r) th.AssertNoErr(t, err) th.CheckEquals(t, Manual, *config) }
func TestNextPageURL(t *testing.T) { var page ImagePage var body map[string]interface{} bodyString := []byte(`{"images":{"links":[{"href":"http://192.154.23.87/12345/images/image3","rel":"bookmark"}]}, "images_links":[{"href":"http://192.154.23.87/12345/images/image4","rel":"next"}]}`) err := json.Unmarshal(bodyString, &body) if err != nil { t.Fatalf("Error unmarshaling data into page body: %v", err) } page.Body = body expected := "http://192.154.23.87/12345/images/image4" actual, err := page.NextPageURL() th.AssertNoErr(t, err) th.CheckEquals(t, expected, actual) }
func TestAuthenticatedClientV3(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() const ID = "0123456789" th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, ` { "versions": { "values": [ { "status": "stable", "id": "v3.0", "links": [ { "href": "%s", "rel": "self" } ] }, { "status": "stable", "id": "v2.0", "links": [ { "href": "%s", "rel": "self" } ] } ] } } `, th.Endpoint()+"v3/", th.Endpoint()+"v2.0/") }) th.Mux.HandleFunc("/v3/auth/tokens", func(w http.ResponseWriter, r *http.Request) { w.Header().Add("X-Subject-Token", ID) w.WriteHeader(http.StatusCreated) fmt.Fprintf(w, `{ "token": { "expires_at": "2013-02-02T18:30:59.000000Z" } }`) }) options := gophercloud.AuthOptions{ UserID: "me", Password: "******", IdentityEndpoint: th.Endpoint(), } client, err := AuthenticatedClient(options) th.AssertNoErr(t, err) th.CheckEquals(t, ID, client.TokenID) }
func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleListSuccessfully(t) count := 0 err := List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractKeyPairs(page) th.AssertNoErr(t, err) th.CheckDeepEquals(t, os.ExpectedKeyPairSlice, actual) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, 1, count) }
func TestEnumerateSinglePaged(t *testing.T) { callCount := 0 pager := setupSinglePaged() defer testhelper.TeardownHTTP() err := pager.EachPage(func(page Page) (bool, error) { callCount++ expected := []int{1, 2, 3} actual, err := ExtractSingleInts(page) testhelper.AssertNoErr(t, err) testhelper.CheckDeepEquals(t, expected, actual) return true, nil }) testhelper.CheckNoErr(t, err) testhelper.CheckEquals(t, 1, callCount) }
func TestListContainerInfo(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleListContainerInfoSuccessfully(t) count := 0 err := List(fake.ServiceClient(), &os.ListOpts{Full: true}).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractInfo(page) th.AssertNoErr(t, err) th.CheckDeepEquals(t, os.ExpectedListInfo, actual) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, count, 1) }
func TestV2EndpointExact(t *testing.T) { expectedURLs := map[gophercloud.Availability]string{ gophercloud.AvailabilityPublic: "https://public.correct.com/", gophercloud.AvailabilityAdmin: "https://admin.correct.com/", gophercloud.AvailabilityInternal: "https://internal.correct.com/", } for availability, expected := range expectedURLs { actual, err := V2EndpointURL(&catalog2, gophercloud.EndpointOpts{ Type: "same", Name: "same", Region: "same", Availability: availability, }) th.AssertNoErr(t, err) th.CheckEquals(t, expected, actual) } }
func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleListSuccessfully(t) serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0" count := 0 err := List(client.ServiceClient(), serverId).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractVolumeAttachments(page) th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedVolumeAttachmentSlice, actual) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, 1, count) }
func TestListTenants(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleListTenantsSuccessfully(t) count := 0 err := List(client.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractTenants(page) th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedTenantSlice, actual) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, count, 1) }
func TestListContainerNames(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() os.HandleListContainerNamesSuccessfully(t) count := 0 err := List(fake.ServiceClient(), &os.ListOpts{Full: false}).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractNames(page) if err != nil { t.Errorf("Failed to extract container names: %v", err) return false, err } th.CheckDeepEquals(t, os.ExpectedListNames, actual) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, count, 1) }