Adding initial acceptance tests
diff --git a/acceptance/rackspace/lb/v1/common.go b/acceptance/rackspace/lb/v1/common.go
new file mode 100644
index 0000000..921fc92
--- /dev/null
+++ b/acceptance/rackspace/lb/v1/common.go
@@ -0,0 +1,52 @@
+// +build acceptance lbs
+
+package v1
+
+import (
+ "os"
+ "testing"
+
+ "github.com/rackspace/gophercloud"
+ "github.com/rackspace/gophercloud/acceptance/tools"
+ "github.com/rackspace/gophercloud/rackspace"
+ th "github.com/rackspace/gophercloud/testhelper"
+)
+
+func newProvider() (*gophercloud.ProviderClient, error) {
+ opts, err := rackspace.AuthOptionsFromEnv()
+ if err != nil {
+ return nil, err
+ }
+ opts = tools.OnlyRS(opts)
+
+ return rackspace.AuthenticatedClient(opts)
+}
+
+func newClient() (*gophercloud.ServiceClient, error) {
+ provider, err := newProvider()
+ if err != nil {
+ return nil, err
+ }
+
+ return rackspace.NewLBV1(provider, gophercloud.EndpointOpts{
+ Region: os.Getenv("RS_REGION"),
+ })
+}
+
+func newComputeClient() (*gophercloud.ServiceClient, error) {
+ provider, err := newProvider()
+ if err != nil {
+ return nil, err
+ }
+
+ return rackspace.NewComputeV2(provider, gophercloud.EndpointOpts{
+ Region: os.Getenv("RS_REGION"),
+ })
+}
+
+func setup(t *testing.T) *gophercloud.ServiceClient {
+ client, err := newClient()
+ th.AssertNoErr(t, err)
+
+ return client
+}
diff --git a/acceptance/rackspace/lb/v1/lb_test.go b/acceptance/rackspace/lb/v1/lb_test.go
new file mode 100644
index 0000000..7ff736d
--- /dev/null
+++ b/acceptance/rackspace/lb/v1/lb_test.go
@@ -0,0 +1,162 @@
+// +build acceptance lbs
+
+package v1
+
+import (
+ "strconv"
+ "strings"
+ "testing"
+
+ "github.com/rackspace/gophercloud"
+ "github.com/rackspace/gophercloud/acceptance/tools"
+ "github.com/rackspace/gophercloud/pagination"
+ "github.com/rackspace/gophercloud/rackspace/lb/v1/lbs"
+ "github.com/rackspace/gophercloud/rackspace/lb/v1/vips"
+ th "github.com/rackspace/gophercloud/testhelper"
+)
+
+func TestLBs(t *testing.T) {
+ return
+ client := setup(t)
+
+ ids := createLB(t, client, 3)
+
+ listLBProtocols(t, client)
+
+ listLBAlgorithms(t, client)
+
+ listLBs(t, client)
+
+ getLB(t, client, ids[0])
+
+ updateLB(t, client, ids[0])
+
+ deleteLB(t, client, ids[0])
+
+ batchDeleteLBs(t, client, ids[1:])
+}
+
+func createLB(t *testing.T, client *gophercloud.ServiceClient, count int) []int {
+ ids := []int{}
+
+ for i := 0; i < count; i++ {
+ opts := lbs.CreateOpts{
+ Name: tools.RandomString("test_", 5),
+ Port: 80,
+ Protocol: "HTTP",
+ VIPs: []vips.VIP{
+ vips.VIP{Type: vips.PUBLIC},
+ },
+ }
+
+ lb, err := lbs.Create(client, opts).Extract()
+ th.AssertNoErr(t, err)
+
+ t.Logf("Created LB %d - waiting for it to build...", lb.ID)
+ waitForLB(client, lb.ID, lbs.ACTIVE)
+ t.Logf("LB %d has reached ACTIVE state", lb.ID)
+
+ ids = append(ids, lb.ID)
+ }
+
+ return ids
+}
+
+func waitForLB(client *gophercloud.ServiceClient, id int, state lbs.Status) {
+ gophercloud.WaitFor(60, func() (bool, error) {
+ lb, err := lbs.Get(client, id).Extract()
+ if err != nil {
+ return false, err
+ }
+ if lb.Status != state {
+ return false, nil
+ }
+ return true, nil
+ })
+}
+
+func listLBProtocols(t *testing.T, client *gophercloud.ServiceClient) {
+ err := lbs.ListProtocols(client).EachPage(func(page pagination.Page) (bool, error) {
+ pList, err := lbs.ExtractProtocols(page)
+ th.AssertNoErr(t, err)
+
+ for _, p := range pList {
+ t.Logf("Listing protocol: Name [%s]", p.Name)
+ }
+
+ return true, nil
+ })
+ th.AssertNoErr(t, err)
+}
+
+func listLBAlgorithms(t *testing.T, client *gophercloud.ServiceClient) {
+ err := lbs.ListAlgorithms(client).EachPage(func(page pagination.Page) (bool, error) {
+ aList, err := lbs.ExtractAlgorithms(page)
+ th.AssertNoErr(t, err)
+
+ for _, a := range aList {
+ t.Logf("Listing algorithm: Name [%s]", a.Name)
+ }
+
+ return true, nil
+ })
+ th.AssertNoErr(t, err)
+}
+
+func listLBs(t *testing.T, client *gophercloud.ServiceClient) {
+ err := lbs.List(client, lbs.ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
+ lbList, err := lbs.ExtractLBs(page)
+ th.AssertNoErr(t, err)
+
+ for _, lb := range lbList {
+ t.Logf("Listing LB: ID [%d] Name [%s] Protocol [%s] Status [%s] Node count [%d] Port [%d]",
+ lb.ID, lb.Name, lb.Protocol, lb.Status, lb.NodeCount, lb.Port)
+ }
+
+ return true, nil
+ })
+
+ th.AssertNoErr(t, err)
+}
+
+func getLB(t *testing.T, client *gophercloud.ServiceClient, id int) {
+ lb, err := lbs.Get(client, id).Extract()
+ th.AssertNoErr(t, err)
+ t.Logf("Getting LB %d: Created [%s] VIPs [%#v] Logging [%#v] Persistence [%#v] SourceAddrs [%#v]",
+ lb.ID, lb.Created, lb.VIPs, lb.ConnectionLogging, lb.SessionPersistence, lb.SourceAddrs)
+}
+
+func updateLB(t *testing.T, client *gophercloud.ServiceClient, id int) {
+ opts := lbs.UpdateOpts{
+ Name: tools.RandomString("new_", 5),
+ Protocol: "TCP",
+ HalfClosed: lbs.Enabled,
+ Algorithm: "RANDOM",
+ Port: 8080,
+ Timeout: 100,
+ HTTPSRedirect: lbs.Disabled,
+ }
+
+ err := lbs.Update(client, id, opts).ExtractErr()
+ th.AssertNoErr(t, err)
+
+ t.Logf("Updating LB %d - waiting for it to finish", id)
+ waitForLB(client, id, lbs.ACTIVE)
+ t.Logf("LB %d has reached ACTIVE state", id)
+}
+
+func deleteLB(t *testing.T, client *gophercloud.ServiceClient, id int) {
+ err := lbs.Delete(client, id).ExtractErr()
+ th.AssertNoErr(t, err)
+ t.Logf("Deleted %d", id)
+}
+
+func batchDeleteLBs(t *testing.T, client *gophercloud.ServiceClient, ids []int) {
+ err := lbs.BulkDelete(client, ids).ExtractErr()
+ th.AssertNoErr(t, err)
+ strIDs := []string{}
+ for _, id := range ids {
+ strIDs = append(strIDs, strconv.Itoa(id))
+ }
+ t.Logf("Deleted %s", strings.Join(strIDs, ", "))
+}
diff --git a/acceptance/rackspace/lb/v1/node_test.go b/acceptance/rackspace/lb/v1/node_test.go
new file mode 100644
index 0000000..aed802a
--- /dev/null
+++ b/acceptance/rackspace/lb/v1/node_test.go
@@ -0,0 +1,172 @@
+// +build acceptance lbs
+
+package v1
+
+import (
+ "os"
+ "testing"
+
+ "github.com/rackspace/gophercloud"
+ "github.com/rackspace/gophercloud/acceptance/tools"
+ "github.com/rackspace/gophercloud/openstack/compute/v2/extensions/diskconfig"
+ "github.com/rackspace/gophercloud/pagination"
+ "github.com/rackspace/gophercloud/rackspace/compute/v2/servers"
+ "github.com/rackspace/gophercloud/rackspace/lb/v1/lbs"
+ "github.com/rackspace/gophercloud/rackspace/lb/v1/nodes"
+ th "github.com/rackspace/gophercloud/testhelper"
+)
+
+func TestNodes(t *testing.T) {
+ client := setup(t)
+
+ serverIP := findServer(t)
+ ids := createLB(t, client, 1)
+ lbID := ids[0]
+
+ nodeID := addNodes(t, client, lbID, serverIP)
+
+ listNodes(t, client, lbID)
+
+ getNode(t, client, lbID, nodeID)
+
+ updateNode(t, client, lbID, nodeID)
+
+ listEvents(t, client, lbID)
+
+ deleteNode(t, client, lbID, nodeID)
+}
+
+func findServer(t *testing.T) string {
+ var serverIP string
+
+ client, err := newComputeClient()
+ th.AssertNoErr(t, err)
+
+ err = servers.List(client, nil).EachPage(func(page pagination.Page) (bool, error) {
+ sList, err := servers.ExtractServers(page)
+ th.AssertNoErr(t, err)
+
+ for _, s := range sList {
+ serverIP = s.AccessIPv4
+ t.Logf("Found an existing server: ID [%s] Public IP [%s]", s.ID, serverIP)
+ break
+ }
+
+ return true, nil
+ })
+ th.AssertNoErr(t, err)
+
+ if serverIP == "" {
+ t.Log("No server found, creating one")
+
+ imageRef := os.Getenv("RS_IMAGE_ID")
+ if imageRef == "" {
+ t.Fatalf("OS var RS_IMAGE_ID undefined")
+ }
+ flavorRef := os.Getenv("RS_FLAVOR_ID")
+ if flavorRef == "" {
+ t.Fatalf("OS var RS_FLAVOR_ID undefined")
+ }
+
+ opts := &servers.CreateOpts{
+ Name: tools.RandomString("lb_test_", 5),
+ ImageRef: imageRef,
+ FlavorRef: flavorRef,
+ DiskConfig: diskconfig.Manual,
+ }
+
+ s, err := servers.Create(client, opts).Extract()
+ th.AssertNoErr(t, err)
+ serverIP = s.AccessIPv4
+
+ t.Logf("Created server %s, waiting for it to build", s.ID)
+ err = servers.WaitForStatus(client, s.ID, "ACTIVE", 300)
+ th.AssertNoErr(t, err)
+ t.Logf("Server created successfully.")
+ }
+
+ return serverIP
+}
+
+func addNodes(t *testing.T, client *gophercloud.ServiceClient, lbID int, serverIP string) int {
+ opts := nodes.CreateOpts{
+ nodes.CreateOpt{
+ Address: serverIP,
+ Port: 80,
+ Condition: nodes.ENABLED,
+ Type: nodes.PRIMARY,
+ },
+ }
+
+ page := nodes.Create(client, lbID, opts)
+
+ nodeList, err := page.ExtractNodes()
+ th.AssertNoErr(t, err)
+
+ var nodeID int
+ for _, n := range nodeList {
+ nodeID = n.ID
+ }
+ if nodeID == 0 {
+ t.Fatalf("nodeID could not be extracted from create response")
+ }
+
+ t.Logf("Added node %d to LB %d", nodeID, lbID)
+ waitForLB(client, lbID, lbs.ACTIVE)
+
+ return nodeID
+}
+
+func listNodes(t *testing.T, client *gophercloud.ServiceClient, lbID int) {
+ err := nodes.List(client, lbID, nil).EachPage(func(page pagination.Page) (bool, error) {
+ nodeList, err := nodes.ExtractNodes(page)
+ th.AssertNoErr(t, err)
+
+ for _, n := range nodeList {
+ t.Logf("Listing node: ID [%d] Address [%s:%d] Status [%s]", n.ID, n.Address, n.Port, n.Status)
+ }
+
+ return true, nil
+ })
+ th.AssertNoErr(t, err)
+}
+
+func getNode(t *testing.T, client *gophercloud.ServiceClient, lbID int, nodeID int) {
+ node, err := nodes.Get(client, lbID, nodeID).Extract()
+ th.AssertNoErr(t, err)
+ t.Logf("Getting node %d: Type [%s] Weight [%d]", nodeID, node.Type, node.Weight)
+}
+
+func updateNode(t *testing.T, client *gophercloud.ServiceClient, lbID int, nodeID int) {
+ opts := nodes.UpdateOpts{
+ Weight: nodes.IntToPointer(10),
+ Condition: nodes.DRAINING,
+ Type: nodes.SECONDARY,
+ }
+ err := nodes.Update(client, lbID, nodeID, opts).ExtractErr()
+ th.AssertNoErr(t, err)
+ t.Logf("Updated node %d", nodeID)
+ waitForLB(client, lbID, lbs.ACTIVE)
+}
+
+func listEvents(t *testing.T, client *gophercloud.ServiceClient, lbID int) {
+ pager := nodes.ListEvents(client, lbID, nodes.ListEventsOpts{})
+ err := pager.EachPage(func(page pagination.Page) (bool, error) {
+ eventList, err := nodes.ExtractNodeEvents(page)
+ th.AssertNoErr(t, err)
+
+ for _, e := range eventList {
+ t.Logf("Listing events for node %d: Type [%s] Msg [%s] Severity [%s] Date [%s]",
+ e.NodeID, e.Type, e.DetailedMessage, e.Severity, e.Created)
+ }
+
+ return true, nil
+ })
+ th.AssertNoErr(t, err)
+}
+
+func deleteNode(t *testing.T, client *gophercloud.ServiceClient, lbID int, nodeID int) {
+ err := nodes.Delete(client, lbID, nodeID).ExtractErr()
+ th.AssertNoErr(t, err)
+ t.Logf("Deleted node %d", nodeID)
+}