func TestAccounts(t *testing.T) { c, err := createClient(t, false) th.AssertNoErr(t, err) updateHeaders, err := raxAccounts.Update(c, raxAccounts.UpdateOpts{Metadata: map[string]string{"white": "mountains"}}).Extract() th.AssertNoErr(t, err) t.Logf("Update Account Response Headers: %+v\n", updateHeaders) defer func() { updateres := raxAccounts.Update(c, raxAccounts.UpdateOpts{Metadata: map[string]string{"white": ""}}) th.AssertNoErr(t, updateres.Err) metadata, err := raxAccounts.Get(c).ExtractMetadata() th.AssertNoErr(t, err) t.Logf("Metadata from Get Account request (after update reverted): %+v\n", metadata) th.CheckEquals(t, metadata["White"], "") }() getResp := raxAccounts.Get(c) th.AssertNoErr(t, getResp.Err) getHeaders, _ := getResp.Extract() t.Logf("Get Account Response Headers: %+v\n", getHeaders) metadata, _ := getResp.ExtractMetadata() t.Logf("Metadata from Get Account request (after update): %+v\n", metadata) th.CheckEquals(t, metadata["White"], "mountains") }
func TestGetExtension(t *testing.T) { service := authenticatedClient(t) ext, err := extensions2.Get(service, "OS-KSCRUD").Extract() th.AssertNoErr(t, err) th.CheckEquals(t, "OpenStack Keystone User CRUD", ext.Name) th.CheckEquals(t, "http://docs.openstack.org/identity/api/ext/OS-KSCRUD/v1.0", ext.Namespace) th.CheckEquals(t, "OS-KSCRUD", ext.Alias) th.CheckEquals(t, "OpenStack extensions to Keystone v2.0 API enabling User Operations.", ext.Description) }
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 TestListURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-keypairs", listURL(c)) }
func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/os-networksv2", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, ` { "networks": [ { "label": "test-network-1", "cidr": "192.168.100.0/24", "id": "d32019d3-bc6e-4319-9c1d-6722fc136a22" }, { "label": "test-network-2", "cidr": "192.30.250.00/18", "id": "db193ab3-96e3-4cb3-8fc5-05f4296d0324" } ] } `) }) client := fake.ServiceClient() count := 0 err := List(client).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractNetworks(page) if err != nil { t.Errorf("Failed to extract networks: %v", err) return false, err } expected := []Network{ Network{ Label: "test-network-1", CIDR: "192.168.100.0/24", ID: "d32019d3-bc6e-4319-9c1d-6722fc136a22", }, Network{ Label: "test-network-2", CIDR: "192.30.250.00/18", ID: "db193ab3-96e3-4cb3-8fc5-05f4296d0324", }, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.CheckEquals(t, 1, count) }
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 (s *CinderV2Suite) TestGetVolumes() { Convey("Given Cinder volumes are requested", s.T(), func() { Convey("When authentication is required", func() { provider, err := openstackintel.Authenticate(th.Endpoint(), "me", "secret", "tenant") th.AssertNoErr(s.T(), err) th.CheckEquals(s.T(), s.Token, provider.TokenID) Convey("and GetVolumes called", func() { dispatch := ServiceV2{} volumes, err := dispatch.GetVolumes(provider) Convey("Then proper limits values are returned", func() { So(len(volumes), ShouldEqual, 2) So(volumes[s.Tenant1ID].Bytes, ShouldEqual, s.Vol1Size*1024*1024*1024) So(volumes[s.Tenant2ID].Bytes, ShouldEqual, s.Vol2Size*1024*1024*1024) So(volumes[s.Tenant1ID].Count, ShouldEqual, 1) So(volumes[s.Tenant2ID].Count, ShouldEqual, 1) }) Convey("and no error reported", func() { So(err, ShouldBeNil) }) }) }) }) }
func TestV3EndpointNoService(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) w.Header().Add("Content-Type", "application/json") fmt.Fprintf(w, ` { "links": { "next": null, "previous": null }, "services": [] } `) }) _, err := V3EndpointURL(fake.ServiceClient(), gophercloud.EndpointOpts{ Type: "nope", Name: "same", Region: "same", Availability: gophercloud.AvailabilityPublic, }) th.CheckEquals(t, gophercloud.ErrServiceNotFound, err) }
func TestV2EndpointNone(t *testing.T) { _, err := V2EndpointURL(&catalog2, gophercloud.EndpointOpts{ Type: "nope", Availability: gophercloud.AvailabilityPublic, }) th.CheckEquals(t, gophercloud.ErrEndpointNotFound, err) }
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 TestCreateURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-floating-ips", createURL(c)) }
func TestGetURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() th.CheckEquals(t, c.Endpoint+"os-quota-sets/wat", getURL(c, "wat")) }
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 TestKeystoneLogin(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() const ID = "0123456789" th.Mux.HandleFunc("/v3/auth/tokens", func(w http.ResponseWriter, r *http.Request) { w.Header().Add("X-Subject-Token", ID) type AuthRequest struct { Auth struct { Identity struct { Password struct { User struct { Domain struct{ Name string } Name string Password string } } } } } var x AuthRequest body, _ := ioutil.ReadAll(r.Body) json.Unmarshal(body, &x) domainName := x.Auth.Identity.Password.User.Domain.Name userName := x.Auth.Identity.Password.User.Name password := x.Auth.Identity.Password.User.Password if domainName == "default" && userName == "testuser" && password == "testpw" { w.WriteHeader(http.StatusCreated) fmt.Fprintf(w, `{ "token": { "expires_at": "2020-02-02T18:30:59.000000Z" } }`) } else { w.WriteHeader(http.StatusUnauthorized) } }) keystoneAuth := New("keystone_auth", th.Endpoint(), http.DefaultTransport, "default", &TestUserIdentityMapper{}) _, ok, err := keystoneAuth.AuthenticatePassword("testuser", "testpw") th.AssertNoErr(t, err) th.CheckEquals(t, ok, true) _, ok, err = keystoneAuth.AuthenticatePassword("testuser", "badpw") th.AssertNoErr(t, err) th.CheckEquals(t, ok, false) _, ok, err = keystoneAuth.AuthenticatePassword("testuser", "") th.AssertNoErr(t, err) th.CheckEquals(t, ok, false) }
func TestGetURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() id := "1" th.CheckEquals(t, c.Endpoint+"os-tenant-networks/"+id, getURL(c, id)) }
func TestDisassociateURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0" th.CheckEquals(t, c.Endpoint+"servers/"+serverId+"/action", disassociateURL(c, serverId)) }
func TestDeleteURL(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() c := client.ServiceClient() id := "1" th.CheckEquals(t, c.Endpoint+"os-floating-ips/"+id, deleteURL(c, id)) }
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 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 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 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 TestUserAgent(t *testing.T) { p := &ProviderClient{} p.UserAgent.Prepend("custom-user-agent/v2.4") expected := "custom-user-agent/v2.4 gophercloud/v1.0" actual := p.UserAgent.Join() th.CheckEquals(t, expected, actual) p.UserAgent.Prepend("another-custom-user-agent/v0.3", "a-third-ua/v5.9") expected = "another-custom-user-agent/v0.3 a-third-ua/v5.9 custom-user-agent/v2.4 gophercloud/v1.0" actual = p.UserAgent.Join() th.CheckEquals(t, expected, actual) p.UserAgent = UserAgent{} expected = "gophercloud/v1.0" actual = p.UserAgent.Join() th.CheckEquals(t, expected, actual) }
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 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 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 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 TestEnableCDNContainer(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() th.Mux.HandleFunc("/testContainer", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "PUT") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) th.TestHeader(t, r, "Accept", "application/json") w.Header().Add("X-Ttl", "259200") w.Header().Add("X-Cdn-Enabled", "True") w.WriteHeader(http.StatusNoContent) }) options := &EnableOpts{CDNEnabled: true, TTL: 259200} actual := Enable(fake.ServiceClient(), "testContainer", options) th.AssertNoErr(t, actual.Err) th.CheckEquals(t, actual.Header["X-Ttl"][0], "259200") th.CheckEquals(t, actual.Header["X-Cdn-Enabled"][0], "True") }
func TestNormalizePathURL(t *testing.T) { baseDir, _ := os.Getwd() rawPath := "template.yaml" basePath, _ := filepath.Abs(".") result, _ := 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, _ = NormalizePathURL(basePath, rawPath) expected = "http://www.google.com" th.CheckEquals(t, expected, result) rawPath = "very/nested/file.yaml" basePath, _ = filepath.Abs(".") result, _ = 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, _ = 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, _ = 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, _ = 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, _ = 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, _ = 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() os.MockUpdateResponse(t) options := &UpdateOpts{Name: "vol-002"} v, err := Update(fake.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)) }