func TestWaitForStatus(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/volumes/1234", func(w http.ResponseWriter, r *http.Request) {
time.Sleep(3 * time.Second)
w.Header().Add("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, `
{
"volume": {
"display_name": "vol-001",
"id": "1234",
"status":"available"
}
}`)
})
err := WaitForStatus(client.ServiceClient(), "1234", "available", 0)
if err == nil {
t.Errorf("Expected error: 'Time Out in WaitFor'")
}
err = WaitForStatus(client.ServiceClient(), "1234", "available", 6)
th.CheckNoErr(t, err)
}
func TestWaitForStatus(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
th.Mux.HandleFunc("/servers/4321", func(w http.ResponseWriter, r *http.Request) {
time.Sleep(2 * time.Second)
w.Header().Add("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
fmt.Fprintf(w, `
{
"server": {
"name": "the-server",
"id": "4321",
"status": "ACTIVE"
}
}`)
})
err := WaitForStatus(client.ServiceClient(), "4321", "ACTIVE", 0)
if err == nil {
t.Errorf("Expected error: 'Time Out in WaitFor'")
}
err = WaitForStatus(client.ServiceClient(), "4321", "ACTIVE", 3)
th.CheckNoErr(t, err)
}
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 := BuildHeaders(&testStruct)
th.CheckNoErr(t, err)
th.CheckDeepEquals(t, expected, actual)
testStruct.Num = 0
_, err = BuildHeaders(&testStruct)
if err == nil {
t.Errorf("Expected error: 'Required header not set'")
}
_, err = BuildHeaders(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()
os.HandleGetSuccessfully(t)
actual, err := Get(fake.ServiceClient()).Extract()
th.CheckNoErr(t, err)
expected := os.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 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)
}
func TestDeleteContainers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleDeleteContainerSuccessfully(t)
res := Delete(fake.ServiceClient(), "testContainer")
th.CheckNoErr(t, res.Err)
}
func TestPing(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandlePingSuccessfully(t)
err := Ping(fake.ServiceClient()).ExtractErr()
th.CheckNoErr(t, err)
}
func TestGetContainers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleGetContainerSuccessfully(t)
_, err := Get(fake.ServiceClient(), "testContainer").ExtractMetadata()
th.CheckNoErr(t, err)
}
func TestGetAccounts(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleGetAccountSuccessfully(t)
options := &UpdateOpts{Metadata: map[string]string{"gophercloud-test": "accounts"}}
res := Update(fake.ServiceClient(), options)
th.CheckNoErr(t, res.Err)
}
func TestUpdateContainers(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleUpdateContainerSuccessfully(t)
options := &os.UpdateOpts{Metadata: map[string]string{"foo": "bar"}}
res := Update(fake.ServiceClient(), "testContainer", options)
th.CheckNoErr(t, res.Err)
}
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)
th.CheckNoErr(t, res.Err)
th.CheckEquals(t, "bar", res.Header["X-Container-Meta-Foo"][0])
}
func TestUpdateAccounts(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleUpdateAccountSuccessfully(t)
expected := map[string]string{"Foo": "bar"}
actual, err := Get(fake.ServiceClient()).ExtractMetadata()
th.CheckNoErr(t, err)
th.CheckDeepEquals(t, expected, actual)
}
func TestUpdateCDNContainer(t *testing.T) {
th.SetupHTTP()
defer th.TeardownHTTP()
os.HandleUpdateContainerSuccessfully(t)
options := &UpdateOpts{TTL: 3600}
res := Update(fake.ServiceClient(), "testContainer", options)
th.CheckNoErr(t, res.Err)
}
func TestNetworkCRUDOperations(t *testing.T) {
Setup(t)
defer Teardown()
// Create a network
n, err := networks.Create(Client, networks.CreateOpts{Name: "sample_network", AdminStateUp: networks.Up}).Extract()
th.AssertNoErr(t, err)
defer networks.Delete(Client, n.ID)
th.AssertEquals(t, n.Name, "sample_network")
th.AssertEquals(t, n.AdminStateUp, true)
networkID := n.ID
// List networks
pager := networks.List(Client, networks.ListOpts{Limit: 2})
err = pager.EachPage(func(page pagination.Page) (bool, error) {
t.Logf("--- Page ---")
networkList, err := networks.ExtractNetworks(page)
th.AssertNoErr(t, err)
for _, n := range networkList {
t.Logf("Network: ID [%s] Name [%s] Status [%s] Is shared? [%s]",
n.ID, n.Name, n.Status, strconv.FormatBool(n.Shared))
}
return true, nil
})
th.CheckNoErr(t, err)
// Get a network
if networkID == "" {
t.Fatalf("In order to retrieve a network, the NetworkID must be set")
}
n, err = networks.Get(Client, networkID).Extract()
th.AssertNoErr(t, err)
th.AssertEquals(t, n.Status, "ACTIVE")
th.AssertDeepEquals(t, n.Subnets, []string{})
th.AssertEquals(t, n.Name, "sample_network")
th.AssertEquals(t, n.AdminStateUp, true)
th.AssertEquals(t, n.Shared, false)
th.AssertEquals(t, n.ID, networkID)
// Update network
n, err = networks.Update(Client, networkID, networks.UpdateOpts{Name: "new_network_name"}).Extract()
th.AssertNoErr(t, err)
th.AssertEquals(t, n.Name, "new_network_name")
// Delete network
res := networks.Delete(Client, networkID)
th.AssertNoErr(t, res.Err)
}
func TestEnumerateSinglePaged(t *testing.T) {
callCount := 0
pager := setupSinglePaged()
defer testhelper.TeardownHTTP()
err := pager.EachPage(func(page Page) (bool, error) {
callCount++
expected := []int{1, 2, 3}
actual, err := ExtractSingleInts(page)
testhelper.AssertNoErr(t, err)
testhelper.CheckDeepEquals(t, expected, actual)
return true, nil
})
testhelper.CheckNoErr(t, err)
testhelper.CheckEquals(t, 1, callCount)
}
func TestListAPIVersions(t *testing.T) {
Setup(t)
defer Teardown()
pager := apiversions.ListVersions(Client)
err := pager.EachPage(func(page pagination.Page) (bool, error) {
t.Logf("--- Page ---")
versions, err := apiversions.ExtractAPIVersions(page)
th.AssertNoErr(t, err)
for _, v := range versions {
t.Logf("API Version: ID [%s] Status [%s]", v.ID, v.Status)
}
return true, nil
})
th.CheckNoErr(t, err)
}
func TestListAPIResources(t *testing.T) {
Setup(t)
defer Teardown()
pager := apiversions.ListVersionResources(Client, "v2.0")
err := pager.EachPage(func(page pagination.Page) (bool, error) {
t.Logf("--- Page ---")
vrs, err := apiversions.ExtractVersionResources(page)
th.AssertNoErr(t, err)
for _, vr := range vrs {
t.Logf("Network: Name [%s] Collection [%s]", vr.Name, vr.Collection)
}
return true, nil
})
th.CheckNoErr(t, err)
}
func TestListExts(t *testing.T) {
Setup(t)
defer Teardown()
pager := extensions.List(Client)
err := pager.EachPage(func(page pagination.Page) (bool, error) {
t.Logf("--- Page ---")
exts, err := extensions.ExtractExtensions(page)
th.AssertNoErr(t, err)
for _, ext := range exts {
t.Logf("Extension: Name [%s] Description [%s]", ext.Name, ext.Description)
}
return true, nil
})
th.CheckNoErr(t, err)
}
func TestSubnetList(t *testing.T) {
Setup(t)
defer Teardown()
pager := subnets.List(Client, subnets.ListOpts{Limit: 2})
err := pager.EachPage(func(page pagination.Page) (bool, error) {
t.Logf("--- Page ---")
subnetList, err := subnets.ExtractSubnets(page)
th.AssertNoErr(t, err)
for _, s := range subnetList {
t.Logf("Subnet: ID [%s] Name [%s] IP Version [%d] CIDR [%s] GatewayIP [%s]",
s.ID, s.Name, s.IPVersion, s.CIDR, s.GatewayIP)
}
return true, nil
})
th.CheckNoErr(t, err)
}
func TestNetworks(t *testing.T) {
client, err := newClient()
th.AssertNoErr(t, err)
// Create a network
n, err := networks.Create(client, networks.CreateOpts{Label: "sample_network", CIDR: "172.20.0.0/24"}).Extract()
th.AssertNoErr(t, err)
t.Logf("Created network: %+v\n", n)
defer networks.Delete(client, n.ID)
th.AssertEquals(t, n.Label, "sample_network")
th.AssertEquals(t, n.CIDR, "172.20.0.0/24")
networkID := n.ID
// List networks
pager := networks.List(client)
err = pager.EachPage(func(page pagination.Page) (bool, error) {
t.Logf("--- Page ---")
networkList, err := networks.ExtractNetworks(page)
th.AssertNoErr(t, err)
for _, n := range networkList {
t.Logf("Network: ID [%s] Label [%s] CIDR [%s]",
n.ID, n.Label, n.CIDR)
}
return true, nil
})
th.CheckNoErr(t, err)
// Get a network
if networkID == "" {
t.Fatalf("In order to retrieve a network, the NetworkID must be set")
}
n, err = networks.Get(client, networkID).Extract()
t.Logf("Retrieved Network: %+v\n", n)
th.AssertNoErr(t, err)
th.AssertEquals(t, n.CIDR, "172.20.0.0/24")
th.AssertEquals(t, n.Label, "sample_network")
th.AssertEquals(t, n.ID, networkID)
}
func TestVirtualInterfaces(t *testing.T) {
client, err := newClient()
th.AssertNoErr(t, err)
// Create a server
server := createServer(t, client, "")
t.Logf("Created Server: %v\n", server)
defer deleteServer(t, client, server)
serverID := server.ID
// Create a network
n, err := networks.Create(client, networks.CreateOpts{Label: "sample_network", CIDR: "172.20.0.0/24"}).Extract()
th.AssertNoErr(t, err)
t.Logf("Created Network: %v\n", n)
defer networks.Delete(client, n.ID)
networkID := n.ID
// Create a virtual interface
vi, err := virtualinterfaces.Create(client, serverID, networkID).Extract()
th.AssertNoErr(t, err)
t.Logf("Created virtual interface: %+v\n", vi)
defer virtualinterfaces.Delete(client, serverID, vi.ID)
// List virtual interfaces
pager := virtualinterfaces.List(client, serverID)
err = pager.EachPage(func(page pagination.Page) (bool, error) {
t.Logf("--- Page ---")
virtualinterfacesList, err := virtualinterfaces.ExtractVirtualInterfaces(page)
th.AssertNoErr(t, err)
for _, vi := range virtualinterfacesList {
t.Logf("Virtual Interface: ID [%s] MAC Address [%s] IP Addresses [%v]",
vi.ID, vi.MACAddress, vi.IPAddresses)
}
return true, nil
})
th.CheckNoErr(t, err)
}
func listPorts(t *testing.T) {
count := 0
pager := ports.List(base.Client, ports.ListOpts{})
err := pager.EachPage(func(page pagination.Page) (bool, error) {
count++
t.Logf("--- Page ---")
portList, err := portsbinding.ExtractPorts(page)
th.AssertNoErr(t, err)
for _, p := range portList {
t.Logf("Port: ID [%s] Name [%s] HostID [%s] VNICType [%s] VIFType [%s]",
p.ID, p.Name, p.HostID, p.VNICType, p.VIFType)
}
return true, nil
})
th.CheckNoErr(t, err)
if count == 0 {
t.Logf("No pages were iterated over when listing ports")
}
}
func listPorts(t *testing.T) {
count := 0
pager := ports.List(Client, ports.ListOpts{})
err := pager.EachPage(func(page pagination.Page) (bool, error) {
count++
t.Logf("--- Page ---")
portList, err := ports.ExtractPorts(page)
th.AssertNoErr(t, err)
for _, p := range portList {
t.Logf("Port: ID [%s] Name [%s] Status [%d] MAC addr [%s] Fixed IPs [%#v] Security groups [%#v]",
p.ID, p.Name, p.Status, p.MACAddress, p.FixedIPs, p.SecurityGroups)
}
return true, nil
})
th.CheckNoErr(t, err)
if count == 0 {
t.Logf("No pages were iterated over when listing ports")
}
}
func TestWaitFor(t *testing.T) {
err := WaitFor(5, func() (bool, error) {
return true, nil
})
th.CheckNoErr(t, err)
}
