func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListExtensionsSuccessfully(t)
count := 0
extensions.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := extensions.ExtractExtensions(page)
th.AssertNoErr(t, err)
expected := []common.Extension{
common.Extension{
Updated: "2013-01-20T00:00:00-00:00",
Name: "Neutron Service Type Management",
Links: []interface{}{},
Namespace: "http://docs.openstack.org/ext/neutron/service-type/api/v1.0",
Alias: "service-type",
Description: "API for retrieving service providers for Neutron advanced services",
},
}
th.AssertDeepEquals(t, expected, actual)
return true, nil
})
th.CheckEquals(t, 1, count)
}
func TestV2EndpointNone(t *testing.T) {
_, actual := openstack.V2EndpointURL(&catalog2, gophercloud.EndpointOpts{
Type: "nope",
Availability: gophercloud.AvailabilityPublic,
})
expected := &gophercloud.ErrEndpointNotFound{}
th.CheckEquals(t, expected.Error(), actual.Error())
}
func TestUserAgent(t *testing.T) {
p := &gophercloud.ProviderClient{}
p.UserAgent.Prepend("custom-user-agent/2.4.0")
expected := "custom-user-agent/2.4.0 gophercloud/2.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/2.0.0"
actual = p.UserAgent.Join()
th.CheckEquals(t, expected, actual)
p.UserAgent = gophercloud.UserAgent{}
expected = "gophercloud/2.0.0"
actual = p.UserAgent.Join()
th.CheckEquals(t, expected, actual)
}
func TestV3EndpointBadAvailability(t *testing.T) {
_, err := openstack.V3EndpointURL(&catalog3, gophercloud.EndpointOpts{
Type: "same",
Name: "same",
Region: "same",
Availability: "wat",
})
th.CheckEquals(t, "Unexpected availability in endpoint query: wat", err.Error())
}
func TestNormalizePathURL(t *testing.T) {
baseDir, _ := os.Getwd()
rawPath := "template.yaml"
basePath, _ := filepath.Abs(".")
result, _ := gophercloud.NormalizePathURL(basePath, rawPath)
expected := strings.Join([]string{"file:/", filepath.ToSlash(baseDir), "template.yaml"}, "/")
th.CheckEquals(t, expected, result)
rawPath = "http://www.google.com"
basePath, _ = filepath.Abs(".")
result, _ = gophercloud.NormalizePathURL(basePath, rawPath)
expected = "http://www.google.com"
th.CheckEquals(t, expected, result)
rawPath = "very/nested/file.yaml"
basePath, _ = filepath.Abs(".")
result, _ = gophercloud.NormalizePathURL(basePath, rawPath)
expected = strings.Join([]string{"file:/", filepath.ToSlash(baseDir), "very/nested/file.yaml"}, "/")
th.CheckEquals(t, expected, result)
rawPath = "very/nested/file.yaml"
basePath = "http://www.google.com"
result, _ = gophercloud.NormalizePathURL(basePath, rawPath)
expected = "http://www.google.com/very/nested/file.yaml"
th.CheckEquals(t, expected, result)
rawPath = "very/nested/file.yaml/"
basePath = "http://www.google.com/"
result, _ = gophercloud.NormalizePathURL(basePath, rawPath)
expected = "http://www.google.com/very/nested/file.yaml"
th.CheckEquals(t, expected, result)
rawPath = "very/nested/file.yaml"
basePath = "http://www.google.com/even/more"
result, _ = gophercloud.NormalizePathURL(basePath, rawPath)
expected = "http://www.google.com/even/more/very/nested/file.yaml"
th.CheckEquals(t, expected, result)
rawPath = "very/nested/file.yaml"
basePath = strings.Join([]string{"file:/", filepath.ToSlash(baseDir), "only/file/even/more"}, "/")
result, _ = gophercloud.NormalizePathURL(basePath, rawPath)
expected = strings.Join([]string{"file:/", filepath.ToSlash(baseDir), "only/file/even/more/very/nested/file.yaml"}, "/")
th.CheckEquals(t, expected, result)
rawPath = "very/nested/file.yaml/"
basePath = strings.Join([]string{"file:/", filepath.ToSlash(baseDir), "only/file/even/more"}, "/")
result, _ = gophercloud.NormalizePathURL(basePath, rawPath)
expected = strings.Join([]string{"file:/", filepath.ToSlash(baseDir), "only/file/even/more/very/nested/file.yaml"}, "/")
th.CheckEquals(t, expected, result)
}
func TestUpdate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
MockUpdateResponse(t)
options := volumes.UpdateOpts{Name: "vol-002"}
v, err := volumes.Update(client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
th.AssertNoErr(t, err)
th.CheckEquals(t, "vol-002", v.Name)
}
func TestDownloadReader(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleDownloadObjectSuccessfully(t)
response := objects.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 TestNormalizeURL(t *testing.T) {
urls := []string{
"NoSlashAtEnd",
"SlashAtEnd/",
}
expected := []string{
"NoSlashAtEnd/",
"SlashAtEnd/",
}
for i := 0; i < len(expected); i++ {
th.CheckEquals(t, expected[i], gophercloud.NormalizeURL(urls[i]))
}
}
func TestNextPageURL(t *testing.T) {
var page images.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()
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{
Username: "******",
Password: "******",
DomainName: "default",
TenantName: "project",
IdentityEndpoint: th.Endpoint(),
}
client, err := openstack.AuthenticatedClient(options)
th.AssertNoErr(t, err)
th.CheckEquals(t, ID, client.TokenID)
}
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListCDNFlavorsSuccessfully(t)
count := 0
err := flavors.List(fake.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := flavors.ExtractFlavors(page)
if err != nil {
t.Errorf("Failed to extract flavors: %v", err)
return false, err
}
expected := []flavors.Flavor{
{
ID: "europe",
Providers: []flavors.Provider{
{
Provider: "Fastly",
Links: []gophercloud.Link{
gophercloud.Link{
Href: "http://www.fastly.com",
Rel: "provider_url",
},
},
},
},
Links: []gophercloud.Link{
gophercloud.Link{
Href: "https://www.poppycdn.io/v1.0/flavors/europe",
Rel: "self",
},
},
},
}
th.CheckDeepEquals(t, expected, 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 pagination.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 TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListSuccessfully(t)
count := 0
err := tenantnetworks.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := tenantnetworks.ExtractNetworks(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ExpectedNetworkSlice, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, 1, count)
}
func TestListContainerInfo(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListContainerInfoSuccessfully(t)
count := 0
err := containers.List(fake.ServiceClient(), &containers.ListOpts{Full: true}).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := containers.ExtractInfo(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, 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 := openstack.V2EndpointURL(&catalog2, gophercloud.EndpointOpts{
Type: "same",
Name: "same",
Region: "same",
Availability: availability,
})
th.AssertNoErr(t, err)
th.CheckEquals(t, expected, actual)
}
}
func TestListStack(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListSuccessfully(t, FullListOutput)
count := 0
err := stacks.List(fake.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := stacks.ExtractStacks(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ListExpected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, count, 1)
}
func TestListResourceEvents(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListResourceEventsSuccessfully(t, ListResourceEventsOutput)
count := 0
err := stackevents.ListResourceEvents(fake.ServiceClient(), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", "my_resource", nil).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := stackevents.ExtractEvents(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ListResourceEventsExpected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, count, 1)
}
func TestListProjects(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListProjectsSuccessfully(t)
count := 0
err := projects.List(client.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := projects.ExtractProjects(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ExpectedProjectSlice, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, count, 1)
}
func TestCreateContainer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleCreateContainerSuccessfully(t)
options := containers.CreateOpts{ContentType: "application/json", Metadata: map[string]string{"foo": "bar"}}
res := containers.Create(fake.ServiceClient(), "testContainer", options)
th.CheckEquals(t, "bar", res.Header["X-Container-Meta-Foo"][0])
expected := &containers.CreateHeader{
ContentLength: 0,
ContentType: "text/html; charset=UTF-8",
Date: gophercloud.JSONRFC1123(time.Date(2016, time.August, 17, 19, 25, 43, 0, loc)), //Wed, 17 Aug 2016 19:25:43 GMT
TransID: "tx554ed59667a64c61866f1-0058b4ba37",
}
actual, err := res.Extract()
th.CheckNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListSuccessfully(t)
serverID := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
count := 0
err := volumeattach.List(client.ServiceClient(), serverID).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := volumeattach.ExtractVolumeAttachments(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ExpectedVolumeAttachmentSlice, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, 1, count)
}
func TestListResourceTypes(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListTypesSuccessfully(t, ListTypesOutput)
count := 0
err := stackresources.ListTypes(fake.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := stackresources.ExtractResourceTypes(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ListTypesExpected, actual)
// test if sorting works
sort.Sort(actual)
th.CheckDeepEquals(t, SortedListTypesExpected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, 1, count)
}
func TestDownloadExtraction(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleDownloadObjectSuccessfully(t)
response := objects.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))
expected := &objects.DownloadHeader{
ContentLength: 36,
ContentType: "text/plain; charset=utf-8",
Date: gophercloud.JSONRFC1123(time.Date(2009, time.November, 10, 23, 0, 0, 0, loc)),
}
actual, err := response.Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, expected, actual)
}
func TestListContainerNames(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListContainerNamesSuccessfully(t)
count := 0
err := containers.List(fake.ServiceClient(), &containers.ListOpts{Full: false}).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := containers.ExtractNames(page)
if err != nil {
t.Errorf("Failed to extract container names: %v", err)
return false, err
}
th.CheckDeepEquals(t, ExpectedListNames, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, count, 1)
}
func TestListAddressesByNetwork(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleNetworkAddressListSuccessfully(t)
expected := ListNetworkAddressesExpected
pages := 0
err := servers.ListAddressesByNetwork(client.ServiceClient(), "asdfasdfasdf", "public").EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := servers.ExtractNetworkAddresses(page)
th.AssertNoErr(t, err)
if len(actual) != 2 {
t.Fatalf("Expected 2 addresses, got %d", len(actual))
}
th.CheckDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, 1, pages)
}
func TestServiceURL(t *testing.T) {
c := &gophercloud.ServiceClient{Endpoint: "http://123.45.67.8/"}
expected := "http://123.45.67.8/more/parts/here"
actual := c.ServiceURL("more", "parts", "here")
th.CheckEquals(t, expected, actual)
}
func TestAuthenticatedClientV2(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, `
{
"versions": {
"values": [
{
"status": "experimental",
"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("/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": [
{
"name": "Cloud Servers",
"type": "compute",
"endpoints": [
{
"tenantId": "t1000",
"publicURL": "https://compute.north.host.com/v1/t1000",
"internalURL": "https://compute.north.internal/v1/t1000",
"region": "North",
"versionId": "1",
"versionInfo": "https://compute.north.host.com/v1/",
"versionList": "https://compute.north.host.com/"
},
{
"tenantId": "t1000",
"publicURL": "https://compute.north.host.com/v1.1/t1000",
"internalURL": "https://compute.north.internal/v1.1/t1000",
"region": "North",
"versionId": "1.1",
"versionInfo": "https://compute.north.host.com/v1.1/",
"versionList": "https://compute.north.host.com/"
}
],
"endpoints_links": []
},
{
"name": "Cloud Files",
"type": "object-store",
"endpoints": [
{
"tenantId": "t1000",
"publicURL": "https://storage.north.host.com/v1/t1000",
"internalURL": "https://storage.north.internal/v1/t1000",
"region": "North",
"versionId": "1",
"versionInfo": "https://storage.north.host.com/v1/",
"versionList": "https://storage.north.host.com/"
},
{
"tenantId": "t1000",
"publicURL": "https://storage.south.host.com/v1/t1000",
"internalURL": "https://storage.south.internal/v1/t1000",
"region": "South",
"versionId": "1",
"versionInfo": "https://storage.south.host.com/v1/",
"versionList": "https://storage.south.host.com/"
}
]
}
]
}
}
`)
})
options := gophercloud.AuthOptions{
Username: "******",
Password: "******",
IdentityEndpoint: th.Endpoint(),
}
client, err := openstack.AuthenticatedClient(options)
th.AssertNoErr(t, err)
th.CheckEquals(t, "01234567890", client.TokenID)
}
func TestIdentityAdminV3Client(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
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": {
"audit_ids": ["VcxU2JYqT8OzfUVvrjEITQ", "qNUTIJntTzO1-XUk5STybw"],
"catalog": [
{
"endpoints": [
{
"id": "39dc322ce86c4111b4f06c2eeae0841b",
"interface": "public",
"region": "RegionOne",
"url": "http://localhost:5000"
},
{
"id": "ec642f27474842e78bf059f6c48f4e99",
"interface": "internal",
"region": "RegionOne",
"url": "http://localhost:5000"
},
{
"id": "c609fc430175452290b62a4242e8a7e8",
"interface": "admin",
"region": "RegionOne",
"url": "http://localhost:35357"
}
],
"id": "4363ae44bdf34a3981fde3b823cb9aa2",
"type": "identity",
"name": "keystone"
}
],
"expires_at": "2013-02-27T18:30:59.999999Z",
"is_domain": false,
"issued_at": "2013-02-27T16:30:59.999999Z",
"methods": [
"password"
],
"project": {
"domain": {
"id": "1789d1",
"name": "example.com"
},
"id": "263fd9",
"name": "project-x"
},
"roles": [
{
"id": "76e72a",
"name": "admin"
},
{
"id": "f4f392",
"name": "member"
}
],
"service_providers": [
{
"auth_url":"https://example.com:5000/v3/OS-FEDERATION/identity_providers/acme/protocols/saml2/auth",
"id": "sp1",
"sp_url": "https://example.com:5000/Shibboleth.sso/SAML2/ECP"
},
{
"auth_url":"https://other.example.com:5000/v3/OS-FEDERATION/identity_providers/acme/protocols/saml2/auth",
"id": "sp2",
"sp_url": "https://other.example.com:5000/Shibboleth.sso/SAML2/ECP"
}
],
"user": {
"domain": {
"id": "1789d1",
"name": "example.com"
},
"id": "0ca8f6",
"name": "Joe",
"password_expires_at": "2016-11-06T15:32:17.000000"
}
}
}
`)
})
options := gophercloud.AuthOptions{
Username: "******",
Password: "******",
DomainID: "12345",
IdentityEndpoint: th.Endpoint(),
}
pc, err := openstack.AuthenticatedClient(options)
th.AssertNoErr(t, err)
sc, err := openstack.NewIdentityV3(pc, gophercloud.EndpointOpts{
Availability: gophercloud.AvailabilityAdmin,
})
th.AssertNoErr(t, err)
th.CheckEquals(t, "http://localhost:35357/", sc.Endpoint)
}