func TestListServers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerListSuccessfully(t)
pages := 0
err := servers.List(client.ServiceClient(), servers.ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := servers.ExtractServers(page)
if err != nil {
return false, err
}
if len(actual) != 3 {
t.Fatalf("Expected 3 servers, got %d", len(actual))
}
th.CheckDeepEquals(t, ServerHerp, actual[0])
th.CheckDeepEquals(t, ServerDerp, actual[1])
th.CheckDeepEquals(t, ServerMerp, actual[2])
return true, nil
})
th.AssertNoErr(t, err)
if pages != 1 {
t.Errorf("Expected 1 page, saw %d", pages)
}
}
func TestListMembers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMemberListSuccessfully(t)
pages := 0
err := pools.ListMembers(fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", pools.ListMembersOpts{}).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := pools.ExtractMembers(page)
if err != nil {
return false, err
}
if len(actual) != 2 {
t.Fatalf("Expected 2 members, got %d", len(actual))
}
th.CheckDeepEquals(t, MemberWeb, actual[0])
th.CheckDeepEquals(t, MemberDb, actual[1])
return true, nil
})
th.AssertNoErr(t, err)
if pages != 1 {
t.Errorf("Expected 1 page, saw %d", pages)
}
}
func TestListPools(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandlePoolListSuccessfully(t)
pages := 0
err := pools.List(fake.ServiceClient(), pools.ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := pools.ExtractPools(page)
if err != nil {
return false, err
}
if len(actual) != 2 {
t.Fatalf("Expected 2 pools, got %d", len(actual))
}
th.CheckDeepEquals(t, PoolWeb, actual[0])
th.CheckDeepEquals(t, PoolDb, actual[1])
return true, nil
})
th.AssertNoErr(t, err)
if pages != 1 {
t.Errorf("Expected 1 page, saw %d", pages)
}
}
// IsSuccessful ensures that a CreateResult was successful and contains the correct token and
// service catalog.
func IsSuccessful(t *testing.T, result tokens.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)
}
// GetIsSuccessful ensures that a GetResult was successful and contains the correct token and
// User Info.
func GetIsSuccessful(t *testing.T, result tokens.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)
}
func TestMaybeInt(t *testing.T) {
testInt := 0
var expected *int
actual := gophercloud.MaybeInt(testInt)
th.CheckDeepEquals(t, expected, actual)
testInt = 4
expected = &testInt
actual = gophercloud.MaybeInt(testInt)
th.CheckDeepEquals(t, expected, actual)
}
func TestMaybeString(t *testing.T) {
testString := ""
var expected *string
actual := gophercloud.MaybeString(testString)
th.CheckDeepEquals(t, expected, actual)
testString = "carol"
expected = &testString
actual = gophercloud.MaybeString(testString)
th.CheckDeepEquals(t, expected, actual)
}
func TestApplyDefaultsToEndpointOpts(t *testing.T) {
eo := gophercloud.EndpointOpts{Availability: gophercloud.AvailabilityPublic}
eo.ApplyDefaults("compute")
expected := gophercloud.EndpointOpts{Availability: gophercloud.AvailabilityPublic, Type: "compute"}
th.CheckDeepEquals(t, expected, eo)
eo = gophercloud.EndpointOpts{Type: "compute"}
eo.ApplyDefaults("object-store")
expected = gophercloud.EndpointOpts{Availability: gophercloud.AvailabilityPublic, Type: "compute"}
th.CheckDeepEquals(t, expected, eo)
}
func TestListAllPools(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandlePoolListSuccessfully(t)
allPages, err := pools.List(fake.ServiceClient(), pools.ListOpts{}).AllPages()
th.AssertNoErr(t, err)
actual, err := pools.ExtractPools(allPages)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, PoolWeb, actual[0])
th.CheckDeepEquals(t, PoolDb, actual[1])
}
func TestListAllMembers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleMemberListSuccessfully(t)
allPages, err := pools.ListMembers(fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", pools.ListMembersOpts{}).AllPages()
th.AssertNoErr(t, err)
actual, err := pools.ExtractMembers(allPages)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, MemberWeb, actual[0])
th.CheckDeepEquals(t, MemberDb, actual[1])
}
func TestListAllLoadbalancers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleLoadbalancerListSuccessfully(t)
allPages, err := loadbalancers.List(fake.ServiceClient(), loadbalancers.ListOpts{}).AllPages()
th.AssertNoErr(t, err)
actual, err := loadbalancers.ExtractLoadBalancers(allPages)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, LoadbalancerWeb, actual[0])
th.CheckDeepEquals(t, LoadbalancerDb, actual[1])
}
func TestListAllHealthmonitors(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleHealthmonitorListSuccessfully(t)
allPages, err := monitors.List(fake.ServiceClient(), monitors.ListOpts{}).AllPages()
th.AssertNoErr(t, err)
actual, err := monitors.ExtractMonitors(allPages)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, HealthmonitorWeb, actual[0])
th.CheckDeepEquals(t, HealthmonitorDb, actual[1])
}
func TestListAllServers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleServerListSuccessfully(t)
allPages, err := servers.List(client.ServiceClient(), servers.ListOpts{}).AllPages()
th.AssertNoErr(t, err)
actual, err := servers.ExtractServers(allPages)
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, ServerHerp, actual[0])
th.CheckDeepEquals(t, ServerDerp, actual[1])
}
func TestBuildQueryString(t *testing.T) {
type testVar string
iFalse := false
opts := struct {
J int `q:"j"`
R string `q:"r,required"`
C bool `q:"c"`
S []string `q:"s"`
TS []testVar `q:"ts"`
TI []int `q:"ti"`
F *bool `q:"f"`
}{
J: 2,
R: "red",
C: true,
S: []string{"one", "two", "three"},
TS: []testVar{"a", "b"},
TI: []int{1, 2},
F: &iFalse,
}
expected := &url.URL{RawQuery: "c=true&f=false&j=2&r=red&s=one&s=two&s=three&ti=1&ti=2&ts=a&ts=b"}
actual, err := gophercloud.BuildQueryString(&opts)
if err != nil {
t.Errorf("Error building query string: %v", err)
}
th.CheckDeepEquals(t, expected, actual)
opts = struct {
J int `q:"j"`
R string `q:"r,required"`
C bool `q:"c"`
S []string `q:"s"`
TS []testVar `q:"ts"`
TI []int `q:"ti"`
F *bool `q:"f"`
}{
J: 2,
C: true,
}
_, err = gophercloud.BuildQueryString(&opts)
if err == nil {
t.Errorf("Expected error: 'Required field not set'")
}
th.CheckDeepEquals(t, expected, actual)
_, err = gophercloud.BuildQueryString(map[string]interface{}{"Number": 4})
if err == nil {
t.Errorf("Expected error: 'Options type is not a struct'")
}
}
func TestGetHomeDocument(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t)
actual, err := base.Get(fake.ServiceClient()).Extract()
th.CheckNoErr(t, err)
expected := base.HomeDocument{
"rel/cdn": map[string]interface{}{
"href-template": "services{?marker,limit}",
"href-vars": map[string]interface{}{
"marker": "param/marker",
"limit": "param/limit",
},
"hints": map[string]interface{}{
"allow": []string{"GET"},
"formats": map[string]interface{}{
"application/json": map[string]interface{}{},
},
},
},
}
th.CheckDeepEquals(t, expected, *actual)
}
func TestListByServer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockListGroupsByServerResponse(t, serverID)
count := 0
err := secgroups.ListByServer(client.ServiceClient(), serverID).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := secgroups.ExtractSecurityGroups(page)
if err != nil {
t.Errorf("Failed to extract users: %v", err)
return false, err
}
expected := []secgroups.SecurityGroup{
{
ID: groupID,
Description: "default",
Name: "default",
Rules: []secgroups.Rule{},
TenantID: "openstack",
},
}
th.CheckDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, count)
}
// Verifies that it is possible to update a share network using nova network
func TestUpdateNova(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
MockUpdateNovaResponse(t)
expected := sharenetworks.ShareNetwork{
ID: "713df749-aac0-4a54-af52-10f6c991e80c",
Name: "net_my2",
CreatedAt: gophercloud.JSONRFC3339MilliNoZ(time.Date(2015, 9, 4, 14, 54, 25, 0, time.UTC)),
Description: "new description",
NetworkType: "",
CIDR: "",
NovaNetID: "new-nova-id",
NeutronNetID: "",
NeutronSubnetID: "",
IPVersion: 4,
SegmentationID: 0,
UpdatedAt: gophercloud.JSONRFC3339MilliNoZ(time.Date(2015, 9, 7, 8, 2, 53, 512184000, time.UTC)),
ProjectID: "16e1ab15c35a457e9c2b2aa189f544e1",
}
options := sharenetworks.UpdateOpts{
Name: "net_my2",
Description: "new description",
NovaNetID: "new-nova-id",
}
v, err := sharenetworks.Update(client.ServiceClient(), "713df749-aac0-4a54-af52-10f6c991e80c", options).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &expected, v)
}
// Verifies that it is possible to get a share network
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
MockGetResponse(t)
var nilTime time.Time
expected := sharenetworks.ShareNetwork{
ID: "7f950b52-6141-4a08-bbb5-bb7ffa3ea5fd",
Name: "net_my1",
CreatedAt: gophercloud.JSONRFC3339MilliNoZ(time.Date(2015, 9, 4, 14, 56, 45, 0, time.UTC)),
Description: "descr",
NetworkType: "",
CIDR: "",
NovaNetID: "",
NeutronNetID: "998b42ee-2cee-4d36-8b95-67b5ca1f2109",
NeutronSubnetID: "53482b62-2c84-4a53-b6ab-30d9d9800d06",
IPVersion: 0,
SegmentationID: 0,
UpdatedAt: gophercloud.JSONRFC3339MilliNoZ(nilTime),
ProjectID: "16e1ab15c35a457e9c2b2aa189f544e1",
}
n, err := sharenetworks.Get(client.ServiceClient(), "7f950b52-6141-4a08-bbb5-bb7ffa3ea5fd").Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &expected, n)
}
// Verifies that share types can be listed correctly
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
MockListResponse(t)
allPages, err := sharetypes.List(client.ServiceClient(), &sharetypes.ListOpts{}).AllPages()
th.AssertNoErr(t, err)
actual, err := sharetypes.ExtractShareTypes(allPages)
th.AssertNoErr(t, err)
expected := []sharetypes.ShareType{
{
ID: "be27425c-f807-4500-a056-d00721db45cf",
Name: "default",
IsPublic: true,
ExtraSpecs: map[string]interface{}{"snapshot_support": "True", "driver_handles_share_servers": "True"},
RequiredExtraSpecs: map[string]interface{}{"driver_handles_share_servers": "True"},
},
{
ID: "f015bebe-c38b-4c49-8832-00143b10253b",
Name: "d",
IsPublic: true,
ExtraSpecs: map[string]interface{}{"driver_handles_share_servers": "false", "snapshot_support": "True"},
RequiredExtraSpecs: map[string]interface{}{"driver_handles_share_servers": "True"},
},
}
th.CheckDeepEquals(t, expected, actual)
}
func TestListAll(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
MockListResponse(t)
allPages, err := volumes.List(client.ServiceClient(), &volumes.ListOpts{}).AllPages()
th.AssertNoErr(t, err)
actual, err := volumes.ExtractVolumes(allPages)
th.AssertNoErr(t, err)
expected := []volumes.Volume{
{
ID: "289da7f8-6440-407c-9fb4-7db01ec49164",
Name: "vol-001",
},
{
ID: "96c3bda7-c82a-4f50-be73-ca7621794835",
Name: "vol-002",
},
}
th.CheckDeepEquals(t, expected, actual)
}
func TestEnumerateMarker(t *testing.T) {
pager := createMarkerPaged(t)
defer testhelper.TeardownHTTP()
callCount := 0
err := pager.EachPage(func(page pagination.Page) (bool, error) {
actual, err := ExtractMarkerStrings(page)
if err != nil {
return false, err
}
t.Logf("Handler invoked with %v", actual)
var expected []string
switch callCount {
case 0:
expected = []string{"aaa", "bbb", "ccc"}
case 1:
expected = []string{"ddd", "eee", "fff"}
case 2:
expected = []string{"ggg", "hhh", "iii"}
default:
t.Fatalf("Unexpected call count: %d", callCount)
return false, nil
}
testhelper.CheckDeepEquals(t, expected, actual)
callCount++
return true, nil
})
testhelper.AssertNoErr(t, err)
testhelper.AssertEquals(t, callCount, 3)
}
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleList(t)
expectedDBs := []databases.Database{
{Name: "anotherexampledb"},
{Name: "exampledb"},
{Name: "nextround"},
{Name: "sampledb"},
{Name: "testingdb"},
}
pages := 0
err := databases.List(fake.ServiceClient(), instanceID).EachPage(func(page pagination.Page) (bool, error) {
pages++
actual, err := databases.ExtractDBs(page)
if err != nil {
return false, err
}
th.CheckDeepEquals(t, expectedDBs, actual)
return true, nil
})
th.AssertNoErr(t, err)
if pages != 1 {
t.Errorf("Expected 1 page, saw %d", pages)
}
}
func TestBuildHeaders(t *testing.T) {
testStruct := struct {
Accept string `h:"Accept"`
Num int `h:"Number,required"`
Style bool `h:"Style"`
}{
Accept: "application/json",
Num: 4,
Style: true,
}
expected := map[string]string{"Accept": "application/json", "Number": "4", "Style": "true"}
actual, err := gophercloud.BuildHeaders(&testStruct)
th.CheckNoErr(t, err)
th.CheckDeepEquals(t, expected, actual)
testStruct.Num = 0
_, err = gophercloud.BuildHeaders(&testStruct)
if err == nil {
t.Errorf("Expected error: 'Required header not set'")
}
_, err = gophercloud.BuildHeaders(map[string]interface{}{"Number": 4})
if err == nil {
t.Errorf("Expected error: 'Options type is not a struct'")
}
}
func TestList(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockListRulesResponse(t)
count := 0
err := defsecrules.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := defsecrules.ExtractDefaultRules(page)
th.AssertNoErr(t, err)
expected := []defsecrules.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 TestRole(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
MockListRoleResponse(t)
count := 0
err := roles.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
count++
actual, err := roles.ExtractRoles(page)
if err != nil {
t.Errorf("Failed to extract users: %v", err)
return false, err
}
expected := []roles.Role{
{
ID: "123",
Name: "compute:admin",
Description: "Nova Administrator",
},
}
th.CheckDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
th.AssertEquals(t, 1, count)
}
func TestListingUserRoles(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
mockListRolesResponse(t)
tenantID := "1d8b6120dcc640fda4fc9194ffc80273"
userID := "c39e3de9be2d4c779f1dfd6abacc176d"
err := users.ListRoles(client.ServiceClient(), tenantID, userID).EachPage(func(page pagination.Page) (bool, error) {
actual, err := users.ExtractRoles(page)
th.AssertNoErr(t, err)
expected := []users.Role{
{ID: "9fe2ff9ee4384b1894a90878d3e92bab", Name: "foo_role"},
{ID: "1ea3d56793574b668e85960fbf651e13", Name: "admin"},
}
th.CheckDeepEquals(t, expected, actual)
return true, nil
})
th.AssertNoErr(t, err)
}
func tokenPostErr(t *testing.T, options gophercloud.AuthOptions, expectedErr error) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleTokenPost(t, "")
actualErr := tokens.Create(client.ServiceClient(), options).Err
th.CheckDeepEquals(t, expectedErr, actualErr)
}
func TestAuthenticatedHeaders(t *testing.T) {
p := &gophercloud.ProviderClient{
TokenID: "1234",
}
expected := map[string]string{"X-Auth-Token": "1234"}
actual := p.AuthenticatedHeaders()
th.CheckDeepEquals(t, expected, actual)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t)
actual, err := quotasets.Get(client.ServiceClient(), FirstTenantID).Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &FirstQuotaSet, actual)
}
func TestGet(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
HandleGetSuccessfully(t)
actual, err := tenantnetworks.Get(client.ServiceClient(), "20c8acc0-f747-4d71-a389-46d078ebf000").Extract()
th.AssertNoErr(t, err)
th.CheckDeepEquals(t, &SecondNetwork, actual)
}
