feat(*): Define composite types that are sortable (#55)

Author: nathansamson

api/apps.go

@@ -10,6 +10,12 @@ type App struct {
 	UUID    string `json:"uuid"`
 }
 
+type Apps []App
+
+func (a Apps) Len() int           { return len(a) }
+func (a Apps) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a Apps) Less(i, j int) bool { return a[i].ID < a[j].ID }
+
 // AppCreateRequest is the definition of POST /v2/apps/.
 type AppCreateRequest struct {
 	ID string `json:"id,omitempty"`

api/apps_test.go

@@ -0,0 +1,24 @@
+package api
+
+import (
+	"sort"
+	"testing"
+)
+
+func TestAppsSorted(t *testing.T) {
+	apps := Apps{
+		{"2014-01-01T00:00:00UTC", "Zulu", "John", "2016-01-02", "zulu.example.com", "d57be2ba-7ae2-4825-9ace-7c86cb893046"},
+		{"2014-01-01T00:00:00UTC", "Alpha", "John", "2016-01-02", "alpha.example.com", "3d501190-1b8e-41ef-94c5-dd9a0bb707bb"},
+		{"2014-01-01T00:00:00UTC", "Gamma", "John", "2016-01-02", "gamma.example.com", "41d95133-fd4d-4f4c-92a2-e454857371cc"},
+		{"2014-01-01T00:00:00UTC", "Beta", "John", "2016-01-02", "beta.example.com", "222ed1aa-e985-4bec-9966-a88215300661"},
+	}
+
+	sort.Sort(apps)
+	expectedAppNames := []string{"Alpha", "Beta", "Gamma", "Zulu"}
+
+	for i, app := range apps {
+		if expectedAppNames[i] != app.ID {
+			t.Errorf("Expected apps to be sorted %v, Got %v at index %v", expectedAppNames[i], app.ID, i)
+		}
+	}
+}

api/domains.go

@@ -9,6 +9,12 @@ type Domain struct {
 	Updated string `json:"updated"`
 }
 
+type Domains []Domain
+
+func (d Domains) Len() int           { return len(d) }
+func (d Domains) Swap(i, j int)      { d[i], d[j] = d[j], d[i] }
+func (d Domains) Less(i, j int) bool { return d[i].Domain < d[j].Domain }
+
 // DomainCreateRequest is the structure of POST /v2/app/<app id>/domains/.
 type DomainCreateRequest struct {
 	Domain string `json:"domain"`

api/domains_test.go

@@ -0,0 +1,24 @@
+package api
+
+import (
+	"sort"
+	"testing"
+)
+
+func TestDomainsSorted(t *testing.T) {
+	domains := Domains{
+		{"Alpha", "", "gamma.example.com", "", ""},
+		{"Alpha", "", "alpha1.example.com", "", ""},
+		{"Alpha", "", "zulu.example.com", "", ""},
+		{"Alpha", "", "delta.example.com", "", ""},
+	}
+
+	sort.Sort(domains)
+	expectedDomains := []string{"alpha1.example.com", "delta.example.com", "gamma.example.com", "zulu.example.com"}
+
+	for i, domain := range domains {
+		if expectedDomains[i] != domain.Domain {
+			t.Errorf("Expected domains to be sorted %v, Got %v at index %v", expectedDomains[i], domain.Domain, i)
+		}
+	}
+}

api/keys.go

@@ -10,6 +10,12 @@ type Key struct {
 	UUID    string `json:"uuid"`
 }
 
+type Keys []Key
+
+func (k Keys) Len() int           { return len(k) }
+func (k Keys) Swap(i, j int)      { k[i], k[j] = k[j], k[i] }
+func (k Keys) Less(i, j int) bool { return k[i].ID < k[j].ID }
+
 // KeyCreateRequest is the definition of POST /v2/keys/.
 type KeyCreateRequest struct {
 	ID     string `json:"id"`

api/keys_test.go

@@ -0,0 +1,24 @@
+package api
+
+import (
+	"sort"
+	"testing"
+)
+
+func TestKeysSorted(t *testing.T) {
+	keys := Keys{
+		{"", "Delta", "", "", "", ""},
+		{"", "Alpha", "", "", "", ""},
+		{"", "Gamma", "", "", "", ""},
+		{"", "Zeta", "", "", "", ""},
+	}
+
+	sort.Sort(keys)
+	expectedKeys := []string{"Alpha", "Delta", "Gamma", "Zeta"}
+
+	for i, key := range keys {
+		if expectedKeys[i] != key.ID {
+			t.Errorf("Expected domains to be sorted %v, Got %v at index %v", expectedKeys[i], key.ID, i)
+		}
+	}
+}

api/ps.go

@@ -10,3 +10,20 @@ type Pods struct {
 	State   string    `json:"state"`
 	Started time.Time `json:"started"`
 }
+
+type PodsList []Pods
+
+func (p PodsList) Len() int           { return len(p) }
+func (p PodsList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+func (p PodsList) Less(i, j int) bool { return p[i].Name < p[j].Name }
+
+type PodType struct {
+	Type     string
+	PodsList PodsList
+}
+
+type PodTypes []PodType
+
+func (p PodTypes) Len() int           { return len(p) }
+func (p PodTypes) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+func (p PodTypes) Less(i, j int) bool { return p[i].Type < p[j].Type }

api/ps_test.go

@@ -0,0 +1,44 @@
+package api
+
+import (
+	"sort"
+	"testing"
+
+	"github.com/deis/controller-sdk-go/pkg/time"
+)
+
+func TestPodsListSorted(t *testing.T) {
+	pods := PodsList{
+		{"", "web", "web.fsdfgh4", "up", time.Time{}},
+		{"", "web", "web.asdfgh1", "up", time.Time{}},
+		{"", "web", "web.csdfgh3", "up", time.Time{}},
+		{"", "web", "web.bsdfgh2", "up", time.Time{}},
+	}
+
+	sort.Sort(pods)
+
+	expectedPodNames := []string{"web.asdfgh1", "web.bsdfgh2", "web.csdfgh3", "web.fsdfgh4"}
+
+	for i, pod := range pods {
+		if expectedPodNames[i] != pod.Name {
+			t.Errorf("Expected pods to be sorted %v, Got %v", expectedPodNames[i], pod.Name)
+		}
+	}
+}
+
+func TestPodTypesSorted(t *testing.T) {
+	podTypes := PodTypes{
+		{"worker", PodsList{}},
+		{"web", PodsList{}},
+		{"clock", PodsList{}},
+	}
+
+	sort.Sort(podTypes)
+	expectedPodTypes := []string{"clock", "web", "worker"}
+
+	for i, podType := range podTypes {
+		if expectedPodTypes[i] != podType.Type {
+			t.Errorf("Expected pod types to be sorted %v, Got %v at index %v", expectedPodTypes[i], podType.Type, i)
+		}
+	}
+}

api/users.go

@@ -33,3 +33,9 @@ Date Joined: %s`
 	return fmt.Sprintf(tpl, u.ID, u.Username, u.Email, u.FirstName, u.LastName, u.LastLogin,
 		u.IsSuperuser, u.IsStaff, u.IsActive, u.DateJoined)
 }
+
+type Users []User
+
+func (u Users) Len() int           { return len(u) }
+func (u Users) Swap(i, j int)      { u[i], u[j] = u[j], u[i] }
+func (u Users) Less(i, j int) bool { return u[i].Username < u[j].Username }

api/users_test.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"sort"
 	"testing"
 )
 
@@ -33,3 +34,21 @@ Date Joined: Yesterday`
 		t.Errorf("Got:\n\n%s\n\nExpected:\n\n%s", user.String(), expected)
 	}
 }
+
+func TestUsersSorted(t *testing.T) {
+	users := Users{
+		{1, "", false, "Zulu", "", "", "", false, false, ""},
+		{2, "", false, "Beta", "", "", "", false, false, ""},
+		{3, "", false, "Gamma", "", "", "", false, false, ""},
+		{4, "", false, "Alpha", "", "", "", false, false, ""},
+	}
+
+	sort.Sort(users)
+	expectedUsernames := []string{"Alpha", "Beta", "Gamma", "Zulu"}
+
+	for i, user := range users {
+		if expectedUsernames[i] != user.Username {
+			t.Errorf("Expected users to be sorted %v, Got %v at index %v", expectedUsernames[i], user.Username, i)
+		}
+	}
+}