Serge Bazanski | be538db | 2020-11-12 00:22:42 +0100 | [diff] [blame] | 1 | package utils |
| 2 | |
| 3 | import ( |
| 4 | "testing" |
| 5 | |
| 6 | apiequality "k8s.io/apimachinery/pkg/api/equality" |
| 7 | "k8s.io/apimachinery/pkg/api/meta" |
| 8 | "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" |
| 9 | "k8s.io/apimachinery/pkg/runtime/schema" |
| 10 | "k8s.io/apimachinery/pkg/util/diff" |
| 11 | "k8s.io/apimachinery/pkg/version" |
| 12 | ) |
| 13 | |
| 14 | func TestParseVersion(t *testing.T) { |
| 15 | tests := []struct { |
| 16 | input version.Info |
| 17 | expected ServerVersion |
| 18 | error bool |
| 19 | }{ |
| 20 | { |
| 21 | input: version.Info{Major: "1", Minor: "6"}, |
| 22 | expected: ServerVersion{Major: 1, Minor: 6}, |
| 23 | }, |
| 24 | { |
| 25 | input: version.Info{Major: "1", Minor: "70"}, |
| 26 | expected: ServerVersion{Major: 1, Minor: 70}, |
| 27 | }, |
| 28 | { |
| 29 | input: version.Info{Major: "1", Minor: "6x"}, |
| 30 | error: true, |
| 31 | }, |
| 32 | { |
| 33 | input: version.Info{Major: "1", Minor: "8+"}, |
| 34 | expected: ServerVersion{Major: 1, Minor: 8}, |
| 35 | }, |
| 36 | { |
| 37 | input: version.Info{Major: "", Minor: "", GitVersion: "v1.8.0"}, |
| 38 | expected: ServerVersion{Major: 1, Minor: 8}, |
| 39 | }, |
| 40 | { |
| 41 | input: version.Info{Major: "1", Minor: "", GitVersion: "v1.8.0"}, |
| 42 | expected: ServerVersion{Major: 1, Minor: 8}, |
| 43 | }, |
| 44 | { |
| 45 | input: version.Info{Major: "", Minor: "8", GitVersion: "v1.8.0"}, |
| 46 | expected: ServerVersion{Major: 1, Minor: 8}, |
| 47 | }, |
| 48 | { |
| 49 | input: version.Info{Major: "", Minor: "", GitVersion: "v1.8.8-test.0"}, |
| 50 | expected: ServerVersion{Major: 1, Minor: 8}, |
| 51 | }, |
| 52 | { |
| 53 | input: version.Info{Major: "1", Minor: "8", GitVersion: "v1.9.0"}, |
| 54 | expected: ServerVersion{Major: 1, Minor: 8}, |
| 55 | }, |
| 56 | { |
| 57 | input: version.Info{Major: "", Minor: "", GitVersion: "v1.a"}, |
| 58 | error: true, |
| 59 | }, |
| 60 | } |
| 61 | |
| 62 | for _, test := range tests { |
| 63 | v, err := ParseVersion(&test.input) |
| 64 | if test.error { |
| 65 | if err == nil { |
| 66 | t.Errorf("test %s should have failed and did not", test.input) |
| 67 | } |
| 68 | continue |
| 69 | } |
| 70 | if err != nil { |
| 71 | t.Errorf("test %v failed: %v", test.input, err) |
| 72 | continue |
| 73 | } |
| 74 | if v != test.expected { |
| 75 | t.Errorf("Expected %v, got %v", test.expected, v) |
| 76 | } |
| 77 | } |
| 78 | } |
| 79 | |
| 80 | func TestVersionCompare(t *testing.T) { |
| 81 | v := ServerVersion{Major: 2, Minor: 3} |
| 82 | tests := []struct { |
| 83 | major, minor, result int |
| 84 | }{ |
| 85 | {major: 1, minor: 0, result: 1}, |
| 86 | {major: 2, minor: 0, result: 1}, |
| 87 | {major: 2, minor: 2, result: 1}, |
| 88 | {major: 2, minor: 3, result: 0}, |
| 89 | {major: 2, minor: 4, result: -1}, |
| 90 | {major: 3, minor: 0, result: -1}, |
| 91 | } |
| 92 | for _, test := range tests { |
| 93 | res := v.Compare(test.major, test.minor) |
| 94 | if res != test.result { |
| 95 | t.Errorf("%d.%d => Expected %d, got %d", test.major, test.minor, test.result, res) |
| 96 | } |
| 97 | } |
| 98 | } |
| 99 | |
| 100 | func TestResourceNameFor(t *testing.T) { |
| 101 | obj := &unstructured.Unstructured{ |
| 102 | Object: map[string]interface{}{ |
| 103 | "apiVersion": "tests/v1alpha1", |
| 104 | "kind": "Test", |
| 105 | "metadata": map[string]interface{}{ |
| 106 | "name": "myname", |
| 107 | "namespace": "mynamespace", |
| 108 | }, |
| 109 | }, |
| 110 | } |
| 111 | |
| 112 | mapper := meta.NewDefaultRESTMapper([]schema.GroupVersion{}) |
| 113 | mapper.Add(schema.GroupVersionKind{Group: "tests", Version: "v1alpha1", Kind: "Test"}, meta.RESTScopeNamespace) |
| 114 | |
| 115 | if n := ResourceNameFor(mapper, obj); n != "tests" { |
| 116 | t.Errorf("Got resource name %q for %v", n, obj) |
| 117 | } |
| 118 | |
| 119 | obj.SetKind("Unknown") |
| 120 | if n := ResourceNameFor(mapper, obj); n != "unknown" { |
| 121 | t.Errorf("Got resource name %q for %v", n, obj) |
| 122 | } |
| 123 | |
| 124 | obj.SetGroupVersionKind(schema.GroupVersionKind{Group: "unknown", Version: "noversion", Kind: "SomeKind"}) |
| 125 | if n := ResourceNameFor(mapper, obj); n != "somekind" { |
| 126 | t.Errorf("Got resource name %q for %v", n, obj) |
| 127 | } |
| 128 | } |
| 129 | |
| 130 | func TestFqName(t *testing.T) { |
| 131 | obj := &unstructured.Unstructured{ |
| 132 | Object: map[string]interface{}{ |
| 133 | "apiVersion": "tests/v1alpha1", |
| 134 | "kind": "Test", |
| 135 | "metadata": map[string]interface{}{ |
| 136 | "name": "myname", |
| 137 | }, |
| 138 | }, |
| 139 | } |
| 140 | |
| 141 | if n := FqName(obj); n != "myname" { |
| 142 | t.Errorf("Got %q for %v", n, obj) |
| 143 | } |
| 144 | |
| 145 | obj.SetNamespace("mynamespace") |
| 146 | if n := FqName(obj); n != "mynamespace.myname" { |
| 147 | t.Errorf("Got %q for %v", n, obj) |
| 148 | } |
| 149 | } |
| 150 | |
| 151 | func TestCompactEncodeRoundTrip(t *testing.T) { |
| 152 | obj := &unstructured.Unstructured{ |
| 153 | Object: map[string]interface{}{ |
| 154 | "apiVersion": "tests/v1alpha1", |
| 155 | "kind": "Test", |
| 156 | "metadata": map[string]interface{}{ |
| 157 | "name": "myname", |
| 158 | }, |
| 159 | "foo": true, |
| 160 | }, |
| 161 | } |
| 162 | |
| 163 | data, err := CompactEncodeObject(obj) |
| 164 | if err != nil { |
| 165 | t.Errorf("CompactEncodeObject returned %v", err) |
| 166 | } |
| 167 | t.Logf("compact encoding is %d bytes", len(data)) |
| 168 | |
| 169 | out := &unstructured.Unstructured{} |
| 170 | if err := CompactDecodeObject(data, out); err != nil { |
| 171 | t.Errorf("CompactDecodeObject returned %v", err) |
| 172 | } |
| 173 | |
| 174 | t.Logf("in: %#v", obj) |
| 175 | t.Logf("out: %#v", out) |
| 176 | if !apiequality.Semantic.DeepEqual(obj, out) { |
| 177 | t.Error("Objects differed: ", diff.ObjectDiff(obj, out)) |
| 178 | } |
| 179 | } |