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