Gotea/docker-machine
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Clean-up dependencies

Browse Source 
Signed-off-by: David Gageot <david@gageot.net>
This commit is contained in:
David Gageot
2015-11-12 19:16:27 +01:00
parent 7a4915e999
commit 89675067eb
612 changed files with 1869 additions and 151003 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/bootfromvolume/requests_test.go generated vendored
View File

@@ -1,51 +0,0 @@
package bootfromvolume
import (
"testing"
"github.com/rackspace/gophercloud/openstack/compute/v2/servers"
th "github.com/rackspace/gophercloud/testhelper"
)
func TestCreateOpts(t *testing.T) {
base := servers.CreateOpts{
Name: "createdserver",
ImageRef: "asdfasdfasdf",
FlavorRef: "performance1-1",
}
ext := CreateOptsExt{
CreateOptsBuilder: base,
BlockDevice: []BlockDevice{
BlockDevice{
UUID: "123456",
SourceType: Image,
DestinationType: "volume",
VolumeSize: 10,
},
},
}
expected := `
{
"server": {
"name": "createdserver",
"imageRef": "asdfasdfasdf",
"flavorRef": "performance1-1",
"block_device_mapping_v2":[
{
"uuid":"123456",
"source_type":"image",
"destination_type":"volume",
"boot_index": "0",
"delete_on_termination": "false",
"volume_size": "10"
}
]
}
}
`
actual, err := ext.ToServerCreateMap()
th.AssertNoErr(t, err)
th.CheckJSONEquals(t, expected, actual)
}

16
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/bootfromvolume/urls_test.go generated vendored
View File

@@ -1,16 +0,0 @@
package bootfromvolume
import (
"testing"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestCreateURL(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
c := client.ServiceClient()
th.CheckEquals(t, c.Endpoint+"os-volumes_boot", createURL(c))
}

100
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/defsecrules/requests_test.go generated vendored
View File

@@ -1,100 +0,0 @@
package defsecrules
import (
"testing"
"github.com/rackspace/gophercloud/openstack/compute/v2/extensions/secgroups"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
const ruleID = "{ruleID}"
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 TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockCreateRuleResponse(t)
opts := CreateOpts{
IPProtocol: "TCP",
FromPort: 80,
ToPort: 80,
CIDR: "10.10.12.0/24",
}
group, err := Create(client.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
expected := &DefaultRule{
ID: ruleID,
FromPort: 80,
ToPort: 80,
IPProtocol: "TCP",
IPRange: secgroups.IPRange{CIDR: "10.10.12.0/24"},
}
th.AssertDeepEquals(t, expected, group)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockGetRuleResponse(t, ruleID)
group, err := Get(client.ServiceClient(), ruleID).Extract()
th.AssertNoErr(t, err)
expected := &DefaultRule{
ID: ruleID,
FromPort: 80,
ToPort: 80,
IPProtocol: "TCP",
IPRange: secgroups.IPRange{CIDR: "10.10.12.0/24"},
}
th.AssertDeepEquals(t, expected, group)
}
func TestDelete(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockDeleteRuleResponse(t, ruleID)
err := Delete(client.ServiceClient(), ruleID).ExtractErr()
th.AssertNoErr(t, err)
}

96
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/delegate_test.go generated vendored
View File

@@ -1,96 +0,0 @@
package extensions
import (
"fmt"
"net/http"
"testing"
common "github.com/rackspace/gophercloud/openstack/common/extensions"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/extensions", 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")
fmt.Fprintf(w, `
{
"extensions": [
{
"updated": "2013-01-20T00:00:00-00:00",
"name": "Neutron Service Type Management",
"links": [],
"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"
}
]
}
`)
})
count := 0
List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := 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 TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/extensions/agent", 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")
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, `
{
"extension": {
"updated": "2013-02-03T10:00:00-00:00",
"name": "agent",
"links": [],
"namespace": "http://docs.openstack.org/ext/agent/api/v2.0",
"alias": "agent",
"description": "The agent management extension."
}
}
`)
})
ext, err := Get(client.ServiceClient(), "agent").Extract()
th.AssertNoErr(t, err)
th.AssertEquals(t, ext.Updated, "2013-02-03T10:00:00-00:00")
th.AssertEquals(t, ext.Name, "agent")
th.AssertEquals(t, ext.Namespace, "http://docs.openstack.org/ext/agent/api/v2.0")
th.AssertEquals(t, ext.Alias, "agent")
th.AssertEquals(t, ext.Description, "The agent management extension.")
}

87
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/diskconfig/requests_test.go generated vendored
View File

@@ -1,87 +0,0 @@
package diskconfig
import (
"testing"
"github.com/rackspace/gophercloud/openstack/compute/v2/servers"
th "github.com/rackspace/gophercloud/testhelper"
)
func TestCreateOpts(t *testing.T) {
base := servers.CreateOpts{
Name: "createdserver",
ImageRef: "asdfasdfasdf",
FlavorRef: "performance1-1",
}
ext := CreateOptsExt{
CreateOptsBuilder: base,
DiskConfig: Manual,
}
expected := `
{
"server": {
"name": "createdserver",
"imageRef": "asdfasdfasdf",
"flavorRef": "performance1-1",
"OS-DCF:diskConfig": "MANUAL"
}
}
`
actual, err := ext.ToServerCreateMap()
th.AssertNoErr(t, err)
th.CheckJSONEquals(t, expected, actual)
}
func TestRebuildOpts(t *testing.T) {
base := servers.RebuildOpts{
Name: "rebuiltserver",
AdminPass: "swordfish",
ImageID: "asdfasdfasdf",
}
ext := RebuildOptsExt{
RebuildOptsBuilder: base,
DiskConfig: Auto,
}
actual, err := ext.ToServerRebuildMap()
th.AssertNoErr(t, err)
expected := `
{
"rebuild": {
"name": "rebuiltserver",
"imageRef": "asdfasdfasdf",
"adminPass": "swordfish",
"OS-DCF:diskConfig": "AUTO"
}
}
`
th.CheckJSONEquals(t, expected, actual)
}
func TestResizeOpts(t *testing.T) {
base := servers.ResizeOpts{
FlavorRef: "performance1-8",
}
ext := ResizeOptsExt{
ResizeOptsBuilder: base,
DiskConfig: Auto,
}
actual, err := ext.ToServerResizeMap()
th.AssertNoErr(t, err)
expected := `
{
"resize": {
"flavorRef": "performance1-8",
"OS-DCF:diskConfig": "AUTO"
}
}
`
th.CheckJSONEquals(t, expected, actual)
}

68
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/diskconfig/results_test.go generated vendored
View File

@@ -1,68 +0,0 @@
package diskconfig
import (
"testing"
"github.com/rackspace/gophercloud/openstack/compute/v2/servers"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
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 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 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: "swordfish",
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 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)
}

80
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/floatingip/requests_test.go generated vendored
View File

@@ -1,80 +0,0 @@
package floatingip
import (
"testing"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListSuccessfully(t)
count := 0
err := List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := ExtractFloatingIPs(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ExpectedFloatingIPsSlice, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, 1, count)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleCreateSuccessfully(t)
actual, err := Create(client.ServiceClient(), CreateOpts{
Pool: "nova",
}).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &CreatedFloatingIP, actual)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t)
actual, err := Get(client.ServiceClient(), "2").Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &SecondFloatingIP, actual)
}
func TestDelete(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleDeleteSuccessfully(t)
err := Delete(client.ServiceClient(), "1").ExtractErr()
th.AssertNoErr(t, err)
}
func TestAssociate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleAssociateSuccessfully(t)
serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
fip := "10.10.10.2"
err := Associate(client.ServiceClient(), serverId, fip).ExtractErr()
th.AssertNoErr(t, err)
}
func TestDisassociate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleDisassociateSuccessfully(t)
serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
fip := "10.10.10.2"
err := Disassociate(client.ServiceClient(), serverId, fip).ExtractErr()
th.AssertNoErr(t, err)
}

60
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/floatingip/urls_test.go generated vendored
View File

@@ -1,60 +0,0 @@
package floatingip
import (
"testing"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestListURL(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
c := client.ServiceClient()
th.CheckEquals(t, c.Endpoint+"os-floating-ips", listURL(c))
}
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()
id := "1"
th.CheckEquals(t, c.Endpoint+"os-floating-ips/"+id, getURL(c, id))
}
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 TestAssociateURL(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", associateURL(c, serverId))
}
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))
}

71
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/keypairs/requests_test.go generated vendored
View File

@@ -1,71 +0,0 @@
package keypairs
import (
"testing"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
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, ExpectedKeyPairSlice, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, 1, count)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleCreateSuccessfully(t)
actual, err := Create(client.ServiceClient(), CreateOpts{
Name: "createdkey",
}).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &CreatedKeyPair, actual)
}
func TestImport(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleImportSuccessfully(t)
actual, err := Create(client.ServiceClient(), CreateOpts{
Name: "importedkey",
PublicKey: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDx8nkQv/zgGgB4rMYmIf+6A4l6Rr+o/6lHBQdW5aYd44bd8JttDCE/F/pNRr0lRE+PiqSPO8nDPHw0010JeMH9gYgnnFlyY3/OcJ02RhIPyyxYpv9FhY+2YiUkpwFOcLImyrxEsYXpD/0d3ac30bNH6Sw9JD9UZHYcpSxsIbECHw== Generated by Nova",
}).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &ImportedKeyPair, actual)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t)
actual, err := Get(client.ServiceClient(), "firstkey").Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &FirstKeyPair, actual)
}
func TestDelete(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleDeleteSuccessfully(t)
err := Delete(client.ServiceClient(), "deletedkey").ExtractErr()
th.AssertNoErr(t, err)
}

40
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/keypairs/urls_test.go generated vendored
View File

@@ -1,40 +0,0 @@
package keypairs
import (
"testing"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestListURL(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
c := client.ServiceClient()
th.CheckEquals(t, c.Endpoint+"os-keypairs", listURL(c))
}
func TestCreateURL(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
c := client.ServiceClient()
th.CheckEquals(t, c.Endpoint+"os-keypairs", createURL(c))
}
func TestGetURL(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
c := client.ServiceClient()
th.CheckEquals(t, c.Endpoint+"os-keypairs/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"))
}

248
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/secgroups/requests_test.go generated vendored
View File

@@ -1,248 +0,0 @@
package secgroups
import (
"testing"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
const (
serverID = "{serverID}"
groupID = "{groupID}"
ruleID = "{ruleID}"
)
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockListGroupsResponse(t)
count := 0
err := List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := ExtractSecurityGroups(page)
if err != nil {
t.Errorf("Failed to extract users: %v", err)
return false, err
}
expected := []SecurityGroup{
SecurityGroup{
ID: groupID,
Description: "default",
Name: "default",
Rules: []Rule{},
TenantID: "openstack",
},
}
th.CheckDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, count)
}
func TestListByServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockListGroupsByServerResponse(t, serverID)
count := 0
err := ListByServer(client.ServiceClient(), serverID).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := ExtractSecurityGroups(page)
if err != nil {
t.Errorf("Failed to extract users: %v", err)
return false, err
}
expected := []SecurityGroup{
SecurityGroup{
ID: groupID,
Description: "default",
Name: "default",
Rules: []Rule{},
TenantID: "openstack",
},
}
th.CheckDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, count)
}
func TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockCreateGroupResponse(t)
opts := CreateOpts{
Name: "test",
Description: "something",
}
group, err := Create(client.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
expected := &SecurityGroup{
ID: groupID,
Name: "test",
Description: "something",
TenantID: "openstack",
Rules: []Rule{},
}
th.AssertDeepEquals(t, expected, group)
}
func TestUpdate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockUpdateGroupResponse(t, groupID)
opts := UpdateOpts{
Name: "new_name",
Description: "new_desc",
}
group, err := Update(client.ServiceClient(), groupID, opts).Extract()
th.AssertNoErr(t, err)
expected := &SecurityGroup{
ID: groupID,
Name: "new_name",
Description: "something",
TenantID: "openstack",
Rules: []Rule{},
}
th.AssertDeepEquals(t, expected, group)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockGetGroupsResponse(t, groupID)
group, err := Get(client.ServiceClient(), groupID).Extract()
th.AssertNoErr(t, err)
expected := &SecurityGroup{
ID: groupID,
Description: "default",
Name: "default",
TenantID: "openstack",
Rules: []Rule{
Rule{
FromPort: 80,
ToPort: 85,
IPProtocol: "TCP",
IPRange: IPRange{CIDR: "0.0.0.0"},
Group: Group{TenantID: "openstack", Name: "default"},
ParentGroupID: groupID,
ID: ruleID,
},
},
}
th.AssertDeepEquals(t, expected, group)
}
func TestGetNumericID(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
numericGroupID := 12345
mockGetNumericIDGroupResponse(t, numericGroupID)
group, err := Get(client.ServiceClient(), "12345").Extract()
th.AssertNoErr(t, err)
expected := &SecurityGroup{ID: "12345"}
th.AssertDeepEquals(t, expected, group)
}
func TestDelete(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockDeleteGroupResponse(t, groupID)
err := Delete(client.ServiceClient(), groupID).ExtractErr()
th.AssertNoErr(t, err)
}
func TestAddRule(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockAddRuleResponse(t)
opts := CreateRuleOpts{
ParentGroupID: groupID,
FromPort: 22,
ToPort: 22,
IPProtocol: "TCP",
CIDR: "0.0.0.0/0",
}
rule, err := CreateRule(client.ServiceClient(), opts).Extract()
th.AssertNoErr(t, err)
expected := &Rule{
FromPort: 22,
ToPort: 22,
Group: Group{},
IPProtocol: "TCP",
ParentGroupID: groupID,
IPRange: IPRange{CIDR: "0.0.0.0/0"},
ID: ruleID,
}
th.AssertDeepEquals(t, expected, rule)
}
func TestDeleteRule(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockDeleteRuleResponse(t, ruleID)
err := DeleteRule(client.ServiceClient(), ruleID).ExtractErr()
th.AssertNoErr(t, err)
}
func TestAddServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockAddServerToGroupResponse(t, serverID)
err := AddServerToGroup(client.ServiceClient(), serverID, "test").ExtractErr()
th.AssertNoErr(t, err)
}
func TestRemoveServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockRemoveServerFromGroupResponse(t, serverID)
err := RemoveServerFromGroup(client.ServiceClient(), serverID, "test").ExtractErr()
th.AssertNoErr(t, err)
}

30
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/startstop/requests_test.go generated vendored
View File

@@ -1,30 +0,0 @@
package startstop
import (
"testing"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
const serverID = "{serverId}"
func TestStart(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockStartServerResponse(t, serverID)
err := Start(client.ServiceClient(), serverID).ExtractErr()
th.AssertNoErr(t, err)
}
func TestStop(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockStopServerResponse(t, serverID)
err := Stop(client.ServiceClient(), serverID).ExtractErr()
th.AssertNoErr(t, err)
}

37
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/tenantnetworks/requests_test.go generated vendored
View File

@@ -1,37 +0,0 @@
package tenantnetworks
import (
"testing"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleListSuccessfully(t)
count := 0
err := List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := ExtractNetworks(page)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ExpectedNetworkSlice, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, 1, count)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t)
actual, err := Get(client.ServiceClient(), "20c8acc0-f747-4d71-a389-46d078ebf000").Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &SecondNetwork, actual)
}

25
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/tenantnetworks/urls_test.go generated vendored
View File

@@ -1,25 +0,0 @@
package tenantnetworks
import (
"testing"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestListURL(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
c := client.ServiceClient()
th.CheckEquals(t, c.Endpoint+"os-tenant-networks", listURL(c))
}
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))
}

65
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/volumeattach/requests_test.go generated vendored
View File

@@ -1,65 +0,0 @@
package volumeattach
import (
"testing"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
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 TestCreate(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleCreateSuccessfully(t)
serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
actual, err := Create(client.ServiceClient(), serverId, CreateOpts{
Device: "/dev/vdc",
VolumeID: "a26887c6-c47b-4654-abb5-dfadf7d3f804",
}).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &CreatedVolumeAttachment, actual)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t)
aId := "a26887c6-c47b-4654-abb5-dfadf7d3f804"
serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
actual, err := Get(client.ServiceClient(), serverId, aId).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &SecondVolumeAttachment, actual)
}
func TestDelete(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleDeleteSuccessfully(t)
aId := "a26887c6-c47b-4654-abb5-dfadf7d3f804"
serverId := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
err := Delete(client.ServiceClient(), serverId, aId).ExtractErr()
th.AssertNoErr(t, err)
}

46
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/extensions/volumeattach/urls_test.go generated vendored
View File

@@ -1,46 +0,0 @@
package volumeattach
import (
"testing"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
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 TestCreateURL(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", createURL(c, serverId))
}
func TestGetURL(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, getURL(c, serverId, aId))
}
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))
}

129
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/flavors/requests_test.go generated vendored
View File

@@ -1,129 +0,0 @@
package flavors
import (
"fmt"
"net/http"
"reflect"
"testing"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
fake "github.com/rackspace/gophercloud/testhelper/client"
)
const tokenID = "blerb"
func TestListFlavors(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/flavors/detail", 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")
r.ParseForm()
marker := r.Form.Get("marker")
switch marker {
case "":
fmt.Fprintf(w, `
{
"flavors": [
{
"id": "1",
"name": "m1.tiny",
"disk": 1,
"ram": 512,
"vcpus": 1
},
{
"id": "2",
"name": "m2.small",
"disk": 10,
"ram": 1024,
"vcpus": 2
}
],
"flavors_links": [
{
"href": "%s/flavors/detail?marker=2",
"rel": "next"
}
]
}
`, th.Server.URL)
case "2":
fmt.Fprintf(w, `{ "flavors": [] }`)
default:
t.Fatalf("Unexpected marker: [%s]", marker)
}
})
pages := 0
err := ListDetail(fake.ServiceClient(), nil).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractFlavors(page)
if err != nil {
return false, err
}
expected := []Flavor{
Flavor{ID: "1", Name: "m1.tiny", Disk: 1, RAM: 512, VCPUs: 1},
Flavor{ID: "2", Name: "m2.small", Disk: 10, RAM: 1024, VCPUs: 2},
}
if !reflect.DeepEqual(expected, actual) {
t.Errorf("Expected %#v, but was %#v", expected, actual)
}
return true, nil
})
if err != nil {
t.Fatal(err)
}
if pages != 1 {
t.Errorf("Expected one page, got %d", pages)
}
}
func TestGetFlavor(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/flavors/12345", 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, `
{
"flavor": {
"id": "1",
"name": "m1.tiny",
"disk": 1,
"ram": 512,
"vcpus": 1,
"rxtx_factor": 1
}
}
`)
})
actual, err := Get(fake.ServiceClient(), "12345").Extract()
if err != nil {
t.Fatalf("Unable to get flavor: %v", err)
}
expected := &Flavor{
ID: "1",
Name: "m1.tiny",
Disk: 1,
RAM: 512,
VCPUs: 1,
RxTxFactor: 1,
}
if !reflect.DeepEqual(expected, actual) {
t.Errorf("Expected %#v, but was %#v", expected, actual)
}
}

26
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/flavors/urls_test.go generated vendored
View File

@@ -1,26 +0,0 @@
package flavors
import (
"testing"
"github.com/rackspace/gophercloud"
th "github.com/rackspace/gophercloud/testhelper"
)
const endpoint = "http://localhost:57909/"
func endpointClient() *gophercloud.ServiceClient {
return &gophercloud.ServiceClient{Endpoint: endpoint}
}
func TestGetURL(t *testing.T) {
actual := getURL(endpointClient(), "foo")
expected := endpoint + "flavors/foo"
th.CheckEquals(t, expected, actual)
}
func TestListURL(t *testing.T) {
actual := listURL(endpointClient())
expected := endpoint + "flavors/detail"
th.CheckEquals(t, expected, actual)
}

175
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/images/requests_test.go generated vendored
View File

@@ -1,175 +0,0 @@
package images
import (
"encoding/json"
"fmt"
"net/http"
"reflect"
"testing"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
fake "github.com/rackspace/gophercloud/testhelper/client"
)
func TestListImages(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", fake.TokenID)
w.Header().Add("Content-Type", "application/json")
r.ParseForm()
marker := r.Form.Get("marker")
switch marker {
case "":
fmt.Fprintf(w, `
{
"images": [
{
"status": "ACTIVE",
"updated": "2014-09-23T12:54:56Z",
"id": "f3e4a95d-1f4f-4989-97ce-f3a1fb8c04d7",
"OS-EXT-IMG-SIZE:size": 476704768,
"name": "F17-x86_64-cfntools",
"created": "2014-09-23T12:54:52Z",
"minDisk": 0,
"progress": 100,
"minRam": 0,
"metadata": {}
},
{
"status": "ACTIVE",
"updated": "2014-09-23T12:51:43Z",
"id": "f90f6034-2570-4974-8351-6b49732ef2eb",
"OS-EXT-IMG-SIZE:size": 13167616,
"name": "cirros-0.3.2-x86_64-disk",
"created": "2014-09-23T12:51:42Z",
"minDisk": 0,
"progress": 100,
"minRam": 0,
"metadata": {}
}
]
}
`)
case "2":
fmt.Fprintf(w, `{ "images": [] }`)
default:
t.Fatalf("Unexpected marker: [%s]", marker)
}
})
pages := 0
options := &ListOpts{Limit: 2}
err := ListDetail(fake.ServiceClient(), options).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractImages(page)
if err != nil {
return false, err
}
expected := []Image{
Image{
ID: "f3e4a95d-1f4f-4989-97ce-f3a1fb8c04d7",
Name: "F17-x86_64-cfntools",
Created: "2014-09-23T12:54:52Z",
Updated: "2014-09-23T12:54:56Z",
MinDisk: 0,
MinRAM: 0,
Progress: 100,
Status: "ACTIVE",
},
Image{
ID: "f90f6034-2570-4974-8351-6b49732ef2eb",
Name: "cirros-0.3.2-x86_64-disk",
Created: "2014-09-23T12:51:42Z",
Updated: "2014-09-23T12:51:43Z",
MinDisk: 0,
MinRAM: 0,
Progress: 100,
Status: "ACTIVE",
},
}
if !reflect.DeepEqual(expected, actual) {
t.Errorf("Unexpected page contents: expected %#v, got %#v", expected, actual)
}
return false, nil
})
if err != nil {
t.Fatalf("EachPage error: %v", err)
}
if pages != 1 {
t.Errorf("Expected one page, got %d", pages)
}
}
func TestGetImage(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/images/12345678", 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, `
{
"image": {
"status": "ACTIVE",
"updated": "2014-09-23T12:54:56Z",
"id": "f3e4a95d-1f4f-4989-97ce-f3a1fb8c04d7",
"OS-EXT-IMG-SIZE:size": 476704768,
"name": "F17-x86_64-cfntools",
"created": "2014-09-23T12:54:52Z",
"minDisk": 0,
"progress": 100,
"minRam": 0,
"metadata": {}
}
}
`)
})
actual, err := Get(fake.ServiceClient(), "12345678").Extract()
if err != nil {
t.Fatalf("Unexpected error from Get: %v", err)
}
expected := &Image{
Status: "ACTIVE",
Updated: "2014-09-23T12:54:56Z",
ID: "f3e4a95d-1f4f-4989-97ce-f3a1fb8c04d7",
Name: "F17-x86_64-cfntools",
Created: "2014-09-23T12:54:52Z",
MinDisk: 0,
Progress: 100,
MinRAM: 0,
}
if !reflect.DeepEqual(expected, actual) {
t.Errorf("Expected %#v, but got %#v", expected, actual)
}
}
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)
}

26
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/images/urls_test.go generated vendored
View File

@@ -1,26 +0,0 @@
package images
import (
"testing"
"github.com/rackspace/gophercloud"
th "github.com/rackspace/gophercloud/testhelper"
)
const endpoint = "http://localhost:57909/"
func endpointClient() *gophercloud.ServiceClient {
return &gophercloud.ServiceClient{Endpoint: endpoint}
}
func TestGetURL(t *testing.T) {
actual := getURL(endpointClient(), "foo")
expected := endpoint + "images/foo"
th.CheckEquals(t, expected, actual)
}
func TestListDetailURL(t *testing.T) {
actual := listDetailURL(endpointClient())
expected := endpoint + "images/detail"
th.CheckEquals(t, expected, actual)
}

327
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/servers/requests_test.go generated vendored
View File

@@ -1,327 +0,0 @@
package servers
import (
"net/http"
"testing"
"github.com/rackspace/gophercloud/pagination"
th "github.com/rackspace/gophercloud/testhelper"
"github.com/rackspace/gophercloud/testhelper/client"
)
func TestListServers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerListSuccessfully(t)
pages := 0
err := List(client.ServiceClient(), ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractServers(page)
if err != nil {
return false, err
}
if len(actual) != 2 {
t.Fatalf("Expected 2 servers, got %d", len(actual))
}
th.CheckDeepEquals(t, ServerHerp, actual[0])
th.CheckDeepEquals(t, ServerDerp, actual[1])
return true, nil
})
th.AssertNoErr(t, err)
if pages != 1 {
t.Errorf("Expected 1 page, saw %d", pages)
}
}
func TestListAllServers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerListSuccessfully(t)
allPages, err := List(client.ServiceClient(), ListOpts{}).AllPages()
th.AssertNoErr(t, err)
actual, err := ExtractServers(allPages)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ServerHerp, actual[0])
th.CheckDeepEquals(t, ServerDerp, actual[1])
}
func TestCreateServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerCreationSuccessfully(t, SingleServerBody)
actual, err := Create(client.ServiceClient(), CreateOpts{
Name: "derp",
ImageRef: "f90f6034-2570-4974-8351-6b49732ef2eb",
FlavorRef: "1",
}).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ServerDerp, *actual)
}
func TestDeleteServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerDeletionSuccessfully(t)
res := Delete(client.ServiceClient(), "asdfasdfasdf")
th.AssertNoErr(t, res.Err)
}
func TestGetServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerGetSuccessfully(t)
client := client.ServiceClient()
actual, err := Get(client, "1234asdf").Extract()
if err != nil {
t.Fatalf("Unexpected Get error: %v", err)
}
th.CheckDeepEquals(t, ServerDerp, *actual)
}
func TestUpdateServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerUpdateSuccessfully(t)
client := client.ServiceClient()
actual, err := Update(client, "1234asdf", UpdateOpts{Name: "new-name"}).Extract()
if err != nil {
t.Fatalf("Unexpected Update error: %v", err)
}
th.CheckDeepEquals(t, ServerDerp, *actual)
}
func TestChangeServerAdminPassword(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleAdminPasswordChangeSuccessfully(t)
res := ChangeAdminPassword(client.ServiceClient(), "1234asdf", "new-password")
th.AssertNoErr(t, res.Err)
}
func TestRebootServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleRebootSuccessfully(t)
res := Reboot(client.ServiceClient(), "1234asdf", SoftReboot)
th.AssertNoErr(t, res.Err)
}
func TestRebuildServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleRebuildSuccessfully(t, SingleServerBody)
opts := RebuildOpts{
Name: "new-name",
AdminPass: "swordfish",
ImageID: "http://104.130.131.164:8774/fcad67a6189847c4aecfa3c81a05783b/images/f90f6034-2570-4974-8351-6b49732ef2eb",
AccessIPv4: "1.2.3.4",
}
actual, err := Rebuild(client.ServiceClient(), "1234asdf", opts).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ServerDerp, *actual)
}
func TestResizeServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
th.TestMethod(t, r, "POST")
th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
th.TestJSONRequest(t, r, `{ "resize": { "flavorRef": "2" } }`)
w.WriteHeader(http.StatusAccepted)
})
res := Resize(client.ServiceClient(), "1234asdf", ResizeOpts{FlavorRef: "2"})
th.AssertNoErr(t, res.Err)
}
func TestConfirmResize(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
th.TestMethod(t, r, "POST")
th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
th.TestJSONRequest(t, r, `{ "confirmResize": null }`)
w.WriteHeader(http.StatusNoContent)
})
res := ConfirmResize(client.ServiceClient(), "1234asdf")
th.AssertNoErr(t, res.Err)
}
func TestRevertResize(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
th.TestMethod(t, r, "POST")
th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
th.TestJSONRequest(t, r, `{ "revertResize": null }`)
w.WriteHeader(http.StatusAccepted)
})
res := RevertResize(client.ServiceClient(), "1234asdf")
th.AssertNoErr(t, res.Err)
}
func TestRescue(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerRescueSuccessfully(t)
res := Rescue(client.ServiceClient(), "1234asdf", RescueOpts{
AdminPass: "1234567890",
})
th.AssertNoErr(t, res.Err)
adminPass, _ := res.Extract()
th.AssertEquals(t, "1234567890", adminPass)
}
func TestGetMetadatum(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadatumGetSuccessfully(t)
expected := map[string]string{"foo": "bar"}
actual, err := Metadatum(client.ServiceClient(), "1234asdf", "foo").Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestCreateMetadatum(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadatumCreateSuccessfully(t)
expected := map[string]string{"foo": "bar"}
actual, err := CreateMetadatum(client.ServiceClient(), "1234asdf", MetadatumOpts{"foo": "bar"}).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestDeleteMetadatum(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadatumDeleteSuccessfully(t)
err := DeleteMetadatum(client.ServiceClient(), "1234asdf", "foo").ExtractErr()
th.AssertNoErr(t, err)
}
func TestGetMetadata(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadataGetSuccessfully(t)
expected := map[string]string{"foo": "bar", "this": "that"}
actual, err := Metadata(client.ServiceClient(), "1234asdf").Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestResetMetadata(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadataResetSuccessfully(t)
expected := map[string]string{"foo": "bar", "this": "that"}
actual, err := ResetMetadata(client.ServiceClient(), "1234asdf", MetadataOpts{
"foo": "bar",
"this": "that",
}).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestUpdateMetadata(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMetadataUpdateSuccessfully(t)
expected := map[string]string{"foo": "baz", "this": "those"}
actual, err := UpdateMetadata(client.ServiceClient(), "1234asdf", MetadataOpts{
"foo": "baz",
"this": "those",
}).Extract()
th.AssertNoErr(t, err)
th.AssertDeepEquals(t, expected, actual)
}
func TestListAddresses(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleAddressListSuccessfully(t)
expected := ListAddressesExpected
pages := 0
err := ListAddresses(client.ServiceClient(), "asdfasdfasdf").EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := ExtractAddresses(page)
th.AssertNoErr(t, err)
if len(actual) != 2 {
t.Fatalf("Expected 2 networks, got %d", len(actual))
}
th.CheckDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.CheckEquals(t, 1, pages)
}
func TestListAddressesByNetwork(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleNetworkAddressListSuccessfully(t)
expected := ListNetworkAddressesExpected
pages := 0
err := ListAddressesByNetwork(client.ServiceClient(), "asdfasdfasdf", "public").EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := 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)
}

68
vendor/github.com/rackspace/gophercloud/openstack/compute/v2/servers/urls_test.go generated vendored
View File

@@ -1,68 +0,0 @@
package servers
import (
"testing"
"github.com/rackspace/gophercloud"
th "github.com/rackspace/gophercloud/testhelper"
)
const endpoint = "http://localhost:57909"
func endpointClient() *gophercloud.ServiceClient {
return &gophercloud.ServiceClient{Endpoint: endpoint}
}
func TestCreateURL(t *testing.T) {
actual := createURL(endpointClient())
expected := endpoint + "servers"
th.CheckEquals(t, expected, actual)
}
func TestListURL(t *testing.T) {
actual := listURL(endpointClient())
expected := endpoint + "servers"
th.CheckEquals(t, expected, actual)
}
func TestListDetailURL(t *testing.T) {
actual := listDetailURL(endpointClient())
expected := endpoint + "servers/detail"
th.CheckEquals(t, expected, actual)
}
func TestDeleteURL(t *testing.T) {
actual := deleteURL(endpointClient(), "foo")
expected := endpoint + "servers/foo"
th.CheckEquals(t, expected, actual)
}
func TestGetURL(t *testing.T) {
actual := getURL(endpointClient(), "foo")
expected := endpoint + "servers/foo"
th.CheckEquals(t, expected, actual)
}
func TestUpdateURL(t *testing.T) {
actual := updateURL(endpointClient(), "foo")
expected := endpoint + "servers/foo"
th.CheckEquals(t, expected, actual)
}
func TestActionURL(t *testing.T) {
actual := actionURL(endpointClient(), "foo")
expected := endpoint + "servers/foo/action"
th.CheckEquals(t, expected, actual)
}
func TestMetadatumURL(t *testing.T) {
actual := metadatumURL(endpointClient(), "foo", "bar")
expected := endpoint + "servers/foo/metadata/bar"
th.CheckEquals(t, expected, actual)
}
func TestMetadataURL(t *testing.T) {
actual := metadataURL(endpointClient(), "foo")
expected := endpoint + "servers/foo/metadata"
th.CheckEquals(t, expected, actual)
}