rackspace/lb/v1/lbs/requests_test.go

package lbs

import (
	"testing"
	"time"

	"github.com/rackspace/gophercloud"
	"github.com/rackspace/gophercloud/pagination"
	"github.com/rackspace/gophercloud/rackspace/lb/v1/nodes"
	"github.com/rackspace/gophercloud/rackspace/lb/v1/sessions"
	"github.com/rackspace/gophercloud/rackspace/lb/v1/throttle"
	"github.com/rackspace/gophercloud/rackspace/lb/v1/vips"
	th "github.com/rackspace/gophercloud/testhelper"
	"github.com/rackspace/gophercloud/testhelper/client"
)

const (
	id1 = 12345
	id2 = 67890
	ts1 = "2010-11-30T03:23:42Z"
	ts2 = "2010-11-30T03:23:44Z"
)

func toTime(t *testing.T, str string) time.Time {
	ts, err := time.Parse(time.RFC3339, str)
	if err != nil {
		t.Fatalf("Could not parse time: %s", err.Error())
	}
	return ts
}

func TestList(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockListLBResponse(t)

	count := 0

	err := List(client.ServiceClient(), ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
		count++
		actual, err := ExtractLBs(page)
		th.AssertNoErr(t, err)

		expected := []LoadBalancer{
			LoadBalancer{
				Name:      "lb-site1",
				ID:        71,
				Protocol:  "HTTP",
				Port:      80,
				Algorithm: "RANDOM",
				Status:    ACTIVE,
				NodeCount: 3,
				VIPs: []vips.VIP{
					vips.VIP{
						ID:      403,
						Address: "206.55.130.1",
						Type:    "PUBLIC",
						Version: "IPV4",
					},
				},
				Created: Datetime{Time: toTime(t, ts1)},
				Updated: Datetime{Time: toTime(t, ts2)},
			},
			LoadBalancer{
				ID:      72,
				Name:    "lb-site2",
				Created: Datetime{Time: toTime(t, "2011-11-30T03:23:42Z")},
				Updated: Datetime{Time: toTime(t, "2011-11-30T03:23:44Z")},
			},
			LoadBalancer{
				ID:      73,
				Name:    "lb-site3",
				Created: Datetime{Time: toTime(t, "2012-11-30T03:23:42Z")},
				Updated: Datetime{Time: toTime(t, "2012-11-30T03:23:44Z")},
			},
		}

		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()

	mockCreateLBResponse(t)

	opts := CreateOpts{
		Name:     "a-new-loadbalancer",
		Port:     80,
		Protocol: "HTTP",
		VIPs: []vips.VIP{
			vips.VIP{ID: 2341},
			vips.VIP{ID: 900001},
		},
		Nodes: []nodes.Node{
			nodes.Node{Address: "10.1.1.1", Port: 80, Condition: "ENABLED"},
		},
	}

	lb, err := Create(client.ServiceClient(), opts).Extract()
	th.AssertNoErr(t, err)

	expected := &LoadBalancer{
		Name:       "a-new-loadbalancer",
		ID:         144,
		Protocol:   "HTTP",
		HalfClosed: false,
		Port:       83,
		Algorithm:  "RANDOM",
		Status:     BUILD,
		Timeout:    30,
		Cluster:    Cluster{Name: "ztm-n01.staging1.lbaas.rackspace.net"},
		Nodes: []nodes.Node{
			nodes.Node{
				Address:   "10.1.1.1",
				ID:        653,
				Port:      80,
				Status:    "ONLINE",
				Condition: "ENABLED",
				Weight:    1,
			},
		},
		VIPs: []vips.VIP{
			vips.VIP{
				ID:      39,
				Address: "206.10.10.210",
				Type:    vips.PUBLIC,
				Version: vips.IPV4,
			},
			vips.VIP{
				ID:      900001,
				Address: "2001:4801:79f1:0002:711b:be4c:0000:0021",
				Type:    vips.PUBLIC,
				Version: vips.IPV6,
			},
		},
		Created:           Datetime{Time: toTime(t, ts1)},
		Updated:           Datetime{Time: toTime(t, ts2)},
		ConnectionLogging: ConnectionLogging{Enabled: false},
	}

	th.AssertDeepEquals(t, expected, lb)
}

func TestBulkDelete(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	ids := []int{id1, id2}

	mockBatchDeleteLBResponse(t, ids)

	err := BulkDelete(client.ServiceClient(), ids).ExtractErr()
	th.AssertNoErr(t, err)
}

func TestDelete(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockDeleteLBResponse(t, id1)

	err := Delete(client.ServiceClient(), id1).ExtractErr()
	th.AssertNoErr(t, err)
}

func TestGet(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockGetLBResponse(t, id1)

	lb, err := Get(client.ServiceClient(), id1).Extract()

	expected := &LoadBalancer{
		Name:              "sample-loadbalancer",
		ID:                2000,
		Protocol:          "HTTP",
		Port:              80,
		Algorithm:         "RANDOM",
		Status:            ACTIVE,
		Timeout:           30,
		ConnectionLogging: ConnectionLogging{Enabled: true},
		VIPs: []vips.VIP{
			vips.VIP{
				ID:      1000,
				Address: "206.10.10.210",
				Type:    "PUBLIC",
				Version: "IPV4",
			},
		},
		Nodes: []nodes.Node{
			nodes.Node{
				Address:   "10.1.1.1",
				ID:        1041,
				Port:      80,
				Status:    "ONLINE",
				Condition: "ENABLED",
			},
			nodes.Node{
				Address:   "10.1.1.2",
				ID:        1411,
				Port:      80,
				Status:    "ONLINE",
				Condition: "ENABLED",
			},
		},
		SessionPersistence: sessions.SessionPersistence{Type: "HTTP_COOKIE"},
		ConnectionThrottle: throttle.ConnectionThrottle{MaxConnections: 100},
		Cluster:            Cluster{Name: "c1.dfw1"},
		Created:            Datetime{Time: toTime(t, ts1)},
		Updated:            Datetime{Time: toTime(t, ts2)},
		SourceAddrs: SourceAddrs{
			IPv4Public:  "10.12.99.28",
			IPv4Private: "10.0.0.0",
			IPv6Public:  "2001:4801:79f1:1::1/64",
		},
	}

	th.AssertDeepEquals(t, expected, lb)
	th.AssertNoErr(t, err)
}

func TestUpdate(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockUpdateLBResponse(t, id1)

	opts := UpdateOpts{
		Name:          "a-new-loadbalancer",
		Protocol:      "TCP",
		HalfClosed:    gophercloud.Enabled,
		Algorithm:     "RANDOM",
		Port:          8080,
		Timeout:       100,
		HTTPSRedirect: gophercloud.Disabled,
	}

	err := Update(client.ServiceClient(), id1, opts).ExtractErr()
	th.AssertNoErr(t, err)
}

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 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 TestIsLoggingEnabled(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockGetLoggingResponse(t, id1)

	res, err := IsLoggingEnabled(client.ServiceClient(), id1)
	th.AssertNoErr(t, err)
	th.AssertEquals(t, true, res)
}

func TestEnablingLogging(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockEnableLoggingResponse(t, id1)

	err := EnableLogging(client.ServiceClient(), id1).ExtractErr()
	th.AssertNoErr(t, err)
}

func TestDisablingLogging(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockDisableLoggingResponse(t, id1)

	err := DisableLogging(client.ServiceClient(), id1).ExtractErr()
	th.AssertNoErr(t, err)
}

func TestGetErrorPage(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockGetErrorPageResponse(t, id1)

	content, err := GetErrorPage(client.ServiceClient(), id1).Extract()
	th.AssertNoErr(t, err)

	expected := &ErrorPage{Content: "<html>DEFAULT ERROR PAGE</html>"}
	th.AssertDeepEquals(t, expected, content)
}

func TestSetErrorPage(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockSetErrorPageResponse(t, id1)

	html := "<html>New error page</html>"
	content, err := SetErrorPage(client.ServiceClient(), id1, html).Extract()
	th.AssertNoErr(t, err)

	expected := &ErrorPage{Content: html}
	th.AssertDeepEquals(t, expected, content)
}

func TestDeleteErrorPage(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockDeleteErrorPageResponse(t, id1)

	err := DeleteErrorPage(client.ServiceClient(), id1).ExtractErr()
	th.AssertNoErr(t, err)
}

func TestGetStats(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockGetStatsResponse(t, id1)

	content, err := GetStats(client.ServiceClient(), id1).Extract()
	th.AssertNoErr(t, err)

	expected := &Stats{
		ConnectTimeout:        10,
		ConnectError:          20,
		ConnectFailure:        30,
		DataTimedOut:          40,
		KeepAliveTimedOut:     50,
		MaxConnections:        60,
		CurrentConnections:    40,
		SSLConnectTimeout:     10,
		SSLConnectError:       20,
		SSLConnectFailure:     30,
		SSLDataTimedOut:       40,
		SSLKeepAliveTimedOut:  50,
		SSLMaxConnections:     60,
		SSLCurrentConnections: 40,
	}
	th.AssertDeepEquals(t, expected, content)
}

func TestIsCached(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockGetCachingResponse(t, id1)

	res, err := IsContentCached(client.ServiceClient(), id1)
	th.AssertNoErr(t, err)
	th.AssertEquals(t, true, res)
}

func TestEnablingCaching(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockEnableCachingResponse(t, id1)

	err := EnableCaching(client.ServiceClient(), id1).ExtractErr()
	th.AssertNoErr(t, err)
}

func TestDisablingCaching(t *testing.T) {
	th.SetupHTTP()
	defer th.TeardownHTTP()

	mockDisableCachingResponse(t, id1)

	err := DisableCaching(client.ServiceClient(), id1).ExtractErr()
	th.AssertNoErr(t, err)
}