unused/disks_test.go at main · grafana/unused · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package unused_test

import (
	"slices"
	"strings"
	"testing"
	"time"

	"github.com/grafana/unused"
	"github.com/grafana/unused/unusedtest"
)

func TestDisksSort(t *testing.T) {
	var (
		now = time.Now()

		foo = unusedtest.NewProvider("foo", nil)
		baz = unusedtest.NewProvider("baz", nil)
		bar = unusedtest.NewProvider("bar", nil)

		gcp = unusedtest.NewDisk("ghi", foo, now.Add(-10*time.Minute), now.Add(-8*time.Minute))
		aws = unusedtest.NewDisk("abc", baz, now.Add(-5*time.Minute), now.Add(-110*time.Second))
		az  = unusedtest.NewDisk("def", bar, now.Add(-2*time.Minute), now.Add(-1*time.Minute-30*time.Second))

		disks = unused.Disks{gcp, aws, az}
	)

	tests := map[string]struct {
		exp []unused.Disk
		by  unused.ByFunc
	}{
		"ByProvider":  {[]unused.Disk{az, aws, gcp}, unused.ByProvider},
		"ByName":      {[]unused.Disk{aws, az, gcp}, unused.ByName},
		"ByCreatedAt": {[]unused.Disk{gcp, aws, az}, unused.ByCreatedAt},
	}

	for n, tt := range tests {
		t.Run(n, func(t *testing.T) {
			disks.Sort(tt.by)

			for i, got := range disks {
				assertEqualDisks(t, tt.exp[i], got)
			}
		})
	}
}

func assertEqualDisks(t *testing.T, p, q unused.Disk) {
	t.Helper()

	if e, g := p.Name(), q.Name(); e != g {
		t.Errorf("expecting name %q, got %q", e, g)
	}

	if e, g := p.Provider(), q.Provider(); e != g {
		t.Errorf("expecting provider %v, got %v", e, g)
	}

	if e, g := p.CreatedAt(), q.CreatedAt(); !e.Equal(g) {
		t.Errorf("expecting created at %v, got %v", e, g)
	}

	mp, mq := p.Meta(), q.Meta()

	if e, g := len(mp), len(mq); e != g {
		t.Fatalf("expecting %d metadata items, got %d", e, g)
	}

	for k, v := range mp {
		if mq[k] != v {
			t.Errorf("expecting metadata %q with value %q, got %q", k, v, mq[k])
		}
	}
}

func TestDisksFilter(t *testing.T) {
	var (
		now = time.Now()

		foo = unusedtest.NewProvider("foo", nil)
		baz = unusedtest.NewProvider("baz", nil)
		bar = unusedtest.NewProvider("bar", nil)

		gcp = unusedtest.NewDisk("ghi", foo, now.Add(-10*time.Minute), now.Add(-8*time.Minute))
		aws = unusedtest.NewDisk("abc", baz, now.Add(-5*time.Minute), now.Add(-10*time.Second))
		az  = unusedtest.NewDisk("def", bar, now.Add(-2*time.Minute), now.Add(-1*time.Minute-30*time.Second))

		disks = unused.Disks{gcp, aws, az}
	)

	tests := []struct {
		filter func(unused.Disk) bool
		exp    unused.Disks
	}{
		{func(_ unused.Disk) bool { return true }, disks},
		{func(_ unused.Disk) bool { return false }, nil},
		{func(d unused.Disk) bool { return d.Provider().Name() == "baz" }, unused.Disks{aws}},
		{func(d unused.Disk) bool { return d.Provider().Name() != "baz" }, unused.Disks{gcp, az}},
		{func(d unused.Disk) bool { return d.CreatedAt().Before(now.Add(-1 * time.Hour)) }, nil},
		{func(d unused.Disk) bool { return d.CreatedAt().Before(now.Add(-1 * time.Second)) }, unused.Disks{gcp, aws, az}},
	}

	eq := func(a, b unused.Disks) bool {
		if len(a) != len(b) {
			return false
		}

		sortBy := func(a, b unused.Disk) int { return strings.Compare(a.Name(), b.Name()) }
		slices.SortFunc(a, sortBy)
		slices.SortFunc(b, sortBy)

		for i, e := range a {
			if b[i].Name() != e.Name() {
				return false
			}
		}
		return true
	}

	for i, tt := range tests {
		got := disks.Filter(tt.filter)
		if !eq(got, tt.exp) {
			t.Errorf("case %d: slices are not equal\nexp: %v\ngot: %v", i, tt.exp, got)
		}
	}
}