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)
}