func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListResponse(t, lbID) count := 0 err := List(client.ServiceClient(), lbID).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractAccessList(page) th.AssertNoErr(t, err) expected := AccessList{ NetworkItem{Address: "206.160.163.21", ID: 21, Type: DENY}, NetworkItem{Address: "206.160.163.22", ID: 22, Type: DENY}, NetworkItem{Address: "206.160.163.23", ID: 23, Type: DENY}, NetworkItem{Address: "206.160.163.24", ID: 24, Type: DENY}, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
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 TestMemberUpdateSuccessfully(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() counter := HandleImageMemberUpdate(t) im, err := Update(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", "8989447062e04a818baf9e073fd04fa7", UpdateOpts{ Status: "accepted", }).Extract() th.AssertEquals(t, 1, counter.Counter) th.AssertNoErr(t, err) createdAt, err := time.Parse(time.RFC3339, "2013-11-26T07:21:21Z") th.AssertNoErr(t, err) updatedAt, err := time.Parse(time.RFC3339, "2013-11-26T07:21:21Z") th.AssertNoErr(t, err) th.AssertDeepEquals(t, ImageMember{ CreatedAt: createdAt, ImageID: "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", MemberID: "8989447062e04a818baf9e073fd04fa7", Schema: "/v2/schemas/member", Status: "accepted", UpdatedAt: updatedAt, }, *im) }
func TestTenants(t *testing.T) { service := authenticatedClient(t) t.Logf("Tenants available to the currently issued token:") count := 0 err := rstenants.List(service, nil).EachPage(func(page pagination.Page) (bool, error) { t.Logf("--- Page %02d ---", count) tenants, err := rstenants.ExtractTenants(page) th.AssertNoErr(t, err) for i, tenant := range tenants { t.Logf("[%02d] id=[%s]", i, tenant.ID) t.Logf(" name=[%s] enabled=[%v]", i, tenant.Name, tenant.Enabled) t.Logf(" description=[%s]", tenant.Description) } count++ return true, nil }) th.AssertNoErr(t, err) if count == 0 { t.Errorf("No tenants listed for your current token.") } }
func TestCreateMemberSuccessfully(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleCreateImageMemberSuccessfully(t) im, err := Create(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", "8989447062e04a818baf9e073fd04fa7").Extract() th.AssertNoErr(t, err) createdAt, err := time.Parse(time.RFC3339, createdAtString) th.AssertNoErr(t, err) updatedAt, err := time.Parse(time.RFC3339, updatedAtString) th.AssertNoErr(t, err) th.AssertDeepEquals(t, ImageMember{ CreatedAt: createdAt, ImageID: "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", MemberID: "8989447062e04a818baf9e073fd04fa7", Schema: "/v2/schemas/member", Status: "pending", UpdatedAt: updatedAt, }, *im) }
func TestListAlgorithms(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListAlgorithmsResponse(t) count := 0 err := ListAlgorithms(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractAlgorithms(page) th.AssertNoErr(t, err) expected := []Algorithm{ Algorithm{Name: "LEAST_CONNECTIONS"}, Algorithm{Name: "RANDOM"}, Algorithm{Name: "ROUND_ROBIN"}, Algorithm{Name: "WEIGHTED_LEAST_CONNECTIONS"}, Algorithm{Name: "WEIGHTED_ROUND_ROBIN"}, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
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 TestListCerts(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListCertsResponse(t, lbID) count := 0 err := ListCerts(client.ServiceClient(), lbID).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractCerts(page) th.AssertNoErr(t, err) expected := []Certificate{ Certificate{ID: 123, HostName: "rackspace.com"}, Certificate{ID: 124, HostName: "*.rackspace.com"}, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListRulesResponse(t) count := 0 err := List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractDefaultRules(page) th.AssertNoErr(t, err) expected := []DefaultRule{ DefaultRule{ FromPort: 80, ID: ruleID, IPProtocol: "TCP", IPRange: secgroups.IPRange{CIDR: "10.10.10.0/24"}, ToPort: 80, }, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
func TestListImages(t *testing.T) { client, err := newClient() th.AssertNoErr(t, err) count := 0 err = images.ListDetail(client, nil).EachPage(func(page pagination.Page) (bool, error) { count++ t.Logf("-- Page %02d --", count) is, err := images.ExtractImages(page) th.AssertNoErr(t, err) for i, image := range is { t.Logf("[%02d] id=[%s]", i, image.ID) t.Logf(" name=[%s]", image.Name) t.Logf(" created=[%s]", image.Created) t.Logf(" updated=[%s]", image.Updated) t.Logf(" min disk=[%d]", image.MinDisk) t.Logf(" min RAM=[%d]", image.MinRAM) t.Logf(" progress=[%d]", image.Progress) t.Logf(" status=[%s]", image.Status) } return true, nil }) th.AssertNoErr(t, err) if count < 1 { t.Errorf("Expected at least one page of images.") } }
func createTestImage(t *testing.T, client *gophercloud.ServiceClient) images.Image { //creating image imageName := tools.RandomString("ACCPT", 16) containerFormat := "ami" createResult := images.Create(client, images.CreateOpts{Name: imageName, ContainerFormat: containerFormat, DiskFormat: containerFormat}) th.AssertNoErr(t, createResult.Err) image, err := createResult.Extract() th.AssertNoErr(t, err) t.Logf("Image %v", image) //checking status image, err = images.Get(client, image.ID).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, image.Status, images.ImageStatusQueued) //uploading image data data := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9} uploadResult := images.Upload(client, image.ID, bytes.NewReader(data)) th.AssertNoErr(t, uploadResult.Err) //checking status image, err = images.Get(client, image.ID).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, image.Status, images.ImageStatusActive) th.AssertEquals(t, image.SizeBytes, 9) return *image }
func TestListBackups(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() fixture.SetupHandler(t, resURL+"/backups", "GET", "", listBackupsResp, 200) pages := 0 err := ListBackups(fake.ServiceClient(), instanceID).EachPage(func(page pagination.Page) (bool, error) { pages++ actual, err := backups.ExtractBackups(page) th.AssertNoErr(t, err) expected := []backups.Backup{ backups.Backup{ Created: timeVal, Description: "Backup from Restored Instance", ID: "87972694-4be2-40f5-83f8-501656e0032a", InstanceID: "29af2cd9-0674-48ab-b87a-b160f00208e6", LocationRef: "http://localhost/path/to/backup", Name: "restored_backup", ParentID: "", Size: 0.141026, Status: "COMPLETED", Updated: timeVal, Datastore: datastores.DatastorePartial{Version: "5.1", Type: "MySQL", VersionID: "20000000-0000-0000-0000-000000000002"}, }, } th.AssertDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, pages) }
func TestMultiEphemeral(t *testing.T) { client, err := newClient() th.AssertNoErr(t, err) if testing.Short() { t.Skip("Skipping test that requires server creation in short mode.") } choices, err := ComputeChoicesFromEnv() if err != nil { t.Fatal(err) } name := tools.RandomString("Gophercloud-", 8) t.Logf("Creating server [%s].", name) bd := []bootfromvolume.BlockDevice{ bootfromvolume.BlockDevice{ BootIndex: 0, UUID: choices.ImageID, SourceType: bootfromvolume.Image, DestinationType: "local", DeleteOnTermination: true, }, bootfromvolume.BlockDevice{ BootIndex: -1, SourceType: bootfromvolume.Blank, DestinationType: "local", DeleteOnTermination: true, GuestFormat: "ext4", VolumeSize: 1, }, bootfromvolume.BlockDevice{ BootIndex: -1, SourceType: bootfromvolume.Blank, DestinationType: "local", DeleteOnTermination: true, GuestFormat: "ext4", VolumeSize: 1, }, } serverCreateOpts := servers.CreateOpts{ Name: name, FlavorRef: choices.FlavorID, ImageRef: choices.ImageID, } server, err := bootfromvolume.Create(client, bootfromvolume.CreateOptsExt{ serverCreateOpts, bd, }).Extract() th.AssertNoErr(t, err) if err = waitForStatus(client, server, "ACTIVE"); err != nil { t.Fatal(err) } t.Logf("Created server: %+v\n", server) defer servers.Delete(client, server.ID) t.Logf("Deleting server [%s]...", name) }
func newClient(t *testing.T) *gophercloud.ServiceClient { authURL := os.Getenv("OS_AUTH_URL") username := os.Getenv("OS_USERNAME") password := os.Getenv("OS_PASSWORD") tenantName := os.Getenv("OS_TENANT_NAME") tenantID := os.Getenv("OS_TENANT_ID") domainName := os.Getenv("OS_DOMAIN_NAME") regionName := os.Getenv("OS_REGION_NAME") t.Logf("Credentials used: OS_AUTH_URL='%s' OS_USERNAME='******' OS_PASSWORD='******' OS_TENANT_NAME='%s' OS_TENANT_NAME='%s' OS_REGION_NAME='%s' OS_TENANT_ID='%s' \n", authURL, username, tenantName, domainName, regionName, tenantID) client, err := openstack.NewClient(authURL) th.AssertNoErr(t, err) ao := gophercloud.AuthOptions{ Username: username, Password: password, TenantName: tenantName, TenantID: tenantID, DomainName: domainName, } err = openstack.AuthenticateV3(client, ao) th.AssertNoErr(t, err) t.Logf("Token is %v", client.TokenID) c, err := openstack.NewImageServiceV2(client, gophercloud.EndpointOpts{ Region: regionName, }) th.AssertNoErr(t, err) return c }
func TestList(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListResponse(t, lbID) count := 0 err := List(client.ServiceClient(), lbID).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractVIPs(page) th.AssertNoErr(t, err) expected := []VIP{ VIP{ID: 1000, Address: "206.10.10.210", Type: "PUBLIC"}, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
func TestListAll(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() MockListResponse(t) allPages, err := List(client.ServiceClient(), &ListOpts{}).AllPages() th.AssertNoErr(t, err) actual, err := ExtractVolumes(allPages) th.AssertNoErr(t, err) expected := []Volume{ Volume{ ID: "289da7f8-6440-407c-9fb4-7db01ec49164", Name: "vol-001", }, Volume{ ID: "96c3bda7-c82a-4f50-be73-ca7621794835", Name: "vol-002", }, } th.CheckDeepEquals(t, expected, actual) }
func TestListProtocols(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListProtocolsResponse(t) count := 0 err := ListProtocols(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) { count++ actual, err := ExtractProtocols(page) th.AssertNoErr(t, err) expected := []Protocol{ Protocol{Name: "DNS_TCP", Port: 53}, Protocol{Name: "DNS_UDP", Port: 53}, Protocol{Name: "FTP", Port: 21}, Protocol{Name: "HTTP", Port: 80}, Protocol{Name: "HTTPS", Port: 443}, Protocol{Name: "IMAPS", Port: 993}, Protocol{Name: "IMAPv4", Port: 143}, } th.CheckDeepEquals(t, expected[0:7], actual) return true, nil }) th.AssertNoErr(t, err) th.AssertEquals(t, 1, count) }
func TestAccounts(t *testing.T) { // Create a provider client for making the HTTP requests. // See common.go in this directory for more information. client := newClient(t) // Update an account's metadata. updateres := accounts.Update(client, accounts.UpdateOpts{Metadata: metadata}) th.AssertNoErr(t, updateres.Err) // Defer the deletion of the metadata set above. defer func() { tempMap := make(map[string]string) for k := range metadata { tempMap[k] = "" } updateres = accounts.Update(client, accounts.UpdateOpts{Metadata: tempMap}) th.AssertNoErr(t, updateres.Err) }() // Retrieve account metadata. getres := accounts.Get(client, nil) th.AssertNoErr(t, getres.Err) // Extract the custom metadata from the 'Get' response. am, err := getres.ExtractMetadata() th.AssertNoErr(t, err) for k := range metadata { if am[k] != metadata[strings.Title(k)] { t.Errorf("Expected custom metadata with key: %s", k) return } } }
func TestListingUserRoles(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() mockListRolesResponse(t) tenantID := "1d8b6120dcc640fda4fc9194ffc80273" userID := "c39e3de9be2d4c779f1dfd6abacc176d" err := ListRoles(client.ServiceClient(), tenantID, userID).EachPage(func(page pagination.Page) (bool, error) { actual, err := ExtractRoles(page) th.AssertNoErr(t, err) expected := []Role{ Role{ID: "9fe2ff9ee4384b1894a90878d3e92bab", Name: "foo_role"}, Role{ID: "1ea3d56793574b668e85960fbf651e13", Name: "admin"}, } th.CheckDeepEquals(t, expected, actual) return true, nil }) th.AssertNoErr(t, err) }
func TestAuthenticate(t *testing.T) { ao := v2AuthOptions(t) service := unauthenticatedClient(t) // Authenticated! result := tokens2.Create(service, tokens2.WrapOptions(ao)) // Extract and print the token. token, err := result.ExtractToken() th.AssertNoErr(t, err) t.Logf("Acquired token: [%s]", token.ID) t.Logf("The token will expire at: [%s]", token.ExpiresAt.String()) t.Logf("The token is valid for tenant: [%#v]", token.Tenant) // Extract and print the service catalog. catalog, err := result.ExtractServiceCatalog() th.AssertNoErr(t, err) t.Logf("Acquired service catalog listing [%d] services", len(catalog.Entries)) for i, entry := range catalog.Entries { t.Logf("[%02d]: name=[%s], type=[%s]", i, entry.Name, entry.Type) for _, endpoint := range entry.Endpoints { t.Logf(" - region=[%s] publicURL=[%s]", endpoint.Region, endpoint.PublicURL) } } }
func createServer(t *testing.T, client *gophercloud.ServiceClient, keyName string) *os.Server { if testing.Short() { t.Skip("Skipping test that requires server creation in short mode.") } options, err := optionsFromEnv() th.AssertNoErr(t, err) name := tools.RandomString("Gophercloud-", 8) opts := &servers.CreateOpts{ Name: name, ImageRef: options.imageID, FlavorRef: options.flavorID, DiskConfig: diskconfig.Manual, } if keyName != "" { opts.KeyPair = keyName } t.Logf("Creating server [%s].", name) s, err := servers.Create(client, opts).Extract() th.AssertNoErr(t, err) t.Logf("Creating server.") err = servers.WaitForStatus(client, s.ID, "ACTIVE", 300) th.AssertNoErr(t, err) t.Logf("Server created successfully.") return s }
func TestImageMemberDetailsAndUpdate(t *testing.T) { // getting current tenant id memberTenantID := os.Getenv("OS_TENANT_ID") if memberTenantID == "" { t.Fatalf("Please define OS_TENANT_ID for image member updating test was '%s'", memberTenantID) } client := newClient(t) //creating image image := createTestImage(t, client) defer deleteImage(t, client, image) //creating member member, err := members.Create(client, image.ID, memberTenantID).Extract() th.AssertNoErr(t, err) th.AssertNotNil(t, member) //checking image member details member, err = members.Get(client, image.ID, memberTenantID).Extract() th.AssertNoErr(t, err) th.AssertNotNil(t, member) th.AssertEquals(t, memberTenantID, member.MemberID) th.AssertEquals(t, "pending", member.Status) t.Logf("Updating image's %s member status for tenant %s to 'accepted' ", image.ID, memberTenantID) //updating image member, err = members.Update(client, image.ID, memberTenantID, "accepted").Extract() th.AssertNoErr(t, err) th.AssertNotNil(t, member) th.AssertEquals(t, "accepted", member.Status) }
func TestBootFromVolume(t *testing.T) { client, err := newClient() th.AssertNoErr(t, err) if testing.Short() { t.Skip("Skipping test that requires server creation in short mode.") } options, err := optionsFromEnv() th.AssertNoErr(t, err) name := tools.RandomString("Gophercloud-", 8) t.Logf("Creating server [%s].", name) bd := []osBFV.BlockDevice{ osBFV.BlockDevice{ UUID: options.imageID, SourceType: osBFV.Image, VolumeSize: 10, }, } server, err := bootfromvolume.Create(client, servers.CreateOpts{ Name: name, FlavorRef: "performance1-1", BlockDevice: bd, }).Extract() th.AssertNoErr(t, err) t.Logf("Created server: %+v\n", server) defer deleteServer(t, client, server) getServer(t, client, server) listServers(t, client) }
func TestShowMemberDetails(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() HandleImageMemberDetails(t) md, err := Get(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", "8989447062e04a818baf9e073fd04fa7").Extract() th.AssertNoErr(t, err) th.AssertNotNil(t, md) createdAt, err := time.Parse(time.RFC3339, "2013-11-26T07:21:21Z") th.AssertNoErr(t, err) updatedAt, err := time.Parse(time.RFC3339, "2013-11-26T07:21:21Z") th.AssertNoErr(t, err) th.AssertDeepEquals(t, ImageMember{ CreatedAt: createdAt, ImageID: "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", MemberID: "8989447062e04a818baf9e073fd04fa7", Schema: "/v2/schemas/member", Status: "pending", UpdatedAt: updatedAt, }, *md) }
// test the fetch function func TestFetch(t *testing.T) { th.SetupHTTP() defer th.TeardownHTTP() baseurl, err := getBasePath() th.AssertNoErr(t, err) fakeURL := strings.Join([]string{baseurl, "file.yaml"}, "/") urlparsed, err := url.Parse(fakeURL) th.AssertNoErr(t, err) th.Mux.HandleFunc(urlparsed.Path, func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") w.Header().Set("Content-Type", "application/jason") w.WriteHeader(http.StatusOK) fmt.Fprintf(w, "Fee-fi-fo-fum") }) client := fakeClient{BaseClient: getHTTPClient()} te := TE{ URL: "file.yaml", client: client, } err = te.Fetch() th.AssertNoErr(t, err) th.AssertEquals(t, fakeURL, te.URL) th.AssertEquals(t, "Fee-fi-fo-fum", string(te.Bin)) }
func TestProjectCRUDOperations(t *testing.T) { serviceClient := createAuthenticatedClient(t) if serviceClient == nil { return } // Create project opts := projects.ProjectOpts{ Enabled: true, Name: "Test project", Description: "This is test project", } project, err := projects.Create(serviceClient, opts).Extract() th.AssertNoErr(t, err) defer projects.Delete(serviceClient, project.ID) th.AssertEquals(t, project.Enabled, true) th.AssertEquals(t, project.Name, "Test project") th.AssertEquals(t, project.Description, "This is test project") // List projects pager := projects.List(serviceClient, projects.ListOpts{}) err = pager.EachPage(func(page pagination.Page) (bool, error) { t.Logf("--- Page ---") projectList, err := projects.ExtractProjects(page) th.AssertNoErr(t, err) for _, p := range projectList { t.Logf("Project: ID [%s] Name [%s] Is enabled? [%s]", p.ID, p.Name, p.Enabled) } return true, nil }) th.CheckNoErr(t, err) projectID := project.ID // Get a project if projectID == "" { t.Fatalf("In order to retrieve a project, the ProjectID must be set") } project, err = projects.Get(serviceClient, projectID).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, project.ID, projectID) th.AssertEquals(t, project.DomainID, "") th.AssertEquals(t, project.ParentID, "") th.AssertEquals(t, project.Enabled, true) th.AssertEquals(t, project.Name, "Test project") th.AssertEquals(t, project.Description, "This is test project") // Update project project, err = projects.Update(serviceClient, projectID, projects.ProjectOpts{Name: "New test project name"}).Extract() th.AssertNoErr(t, err) th.AssertEquals(t, project.Name, "New test project name") // Delete project res := projects.Delete(serviceClient, projectID) th.AssertNoErr(t, res.Err) }
// test if HTTP client can read file type URLS. Read the URL of this file // because if this test is running, it means this file _must_ exist func TestGetHTTPClient(t *testing.T) { client := getHTTPClient() baseurl, err := getBasePath() th.AssertNoErr(t, err) resp, err := client.Get(baseurl) th.AssertNoErr(t, err) th.AssertEquals(t, resp.StatusCode, 200) }
func updateFloatingIP(t *testing.T, ipID, portID string) { t.Logf("Disassociate all ports from IP %s", ipID) _, err := floatingips.Update(base.Client, ipID, floatingips.UpdateOpts{PortID: ""}).Extract() th.AssertNoErr(t, err) t.Logf("Re-associate the port %s", portID) _, err = floatingips.Update(base.Client, ipID, floatingips.UpdateOpts{PortID: portID}).Extract() th.AssertNoErr(t, err) }
// GetIsSuccessful ensures that a GetResult was successful and contains the correct token and // User Info. func GetIsSuccessful(t *testing.T, result GetResult) { token, err := result.ExtractToken() th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedToken, token) user, err := result.ExtractUser() th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedUser, user) }
// IsSuccessful ensures that a CreateResult was successful and contains the correct token and // service catalog. func IsSuccessful(t *testing.T, result CreateResult) { token, err := result.ExtractToken() th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedToken, token) serviceCatalog, err := result.ExtractServiceCatalog() th.AssertNoErr(t, err) th.CheckDeepEquals(t, ExpectedServiceCatalog, serviceCatalog) }