/
ingress_annotations_test.go
113 lines (99 loc) · 3.01 KB
/
ingress_annotations_test.go
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
// -------------------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// --------------------------------------------------------------------------------------------
package annotations
import (
"fmt"
"testing"
"github.com/Azure/application-gateway-kubernetes-ingress/pkg/errors"
"k8s.io/api/extensions/v1beta1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
var ingress = v1beta1.Ingress{
ObjectMeta: v1.ObjectMeta{
Annotations: map[string]string{},
},
}
const (
NoError = "Expected to return %s and no error. Returned %v and %v."
Error = "Expected to return error %s. Returned %v and %v."
)
func TestParseBoolTrue(t *testing.T) {
key := "key"
value := "true"
ingress.Annotations[key] = value
parsedVal, err := parseBool(&ingress, key)
if !parsedVal || err != nil {
t.Error(fmt.Sprintf(NoError, value, parsedVal, err))
}
}
func TestParseBoolFalse(t *testing.T) {
key := "key"
value := "false"
ingress.Annotations[key] = value
parsedVal, err := parseBool(&ingress, key)
if parsedVal || err != nil {
t.Error(fmt.Sprintf(NoError, value, parsedVal, err))
}
}
func TestParseBoolInvalid(t *testing.T) {
key := "key"
value := "nope"
ingress.Annotations[key] = value
parsedVal, err := parseBool(&ingress, key)
if !errors.IsInvalidContent(err) {
t.Error(fmt.Sprintf(Error, err, parsedVal, err))
}
}
func TestParseBoolMissingKey(t *testing.T) {
key := "key"
delete(ingress.Annotations, key)
parsedVal, err := parseBool(&ingress, key)
if !errors.IsMissingAnnotations(err) || parsedVal {
t.Error(fmt.Sprintf(Error, errors.ErrMissingAnnotations, parsedVal, err))
}
}
func TestParseInt32(t *testing.T) {
key := "key"
value := "20"
ingress.Annotations[key] = value
parsedVal, err := parseInt32(&ingress, key)
if err != nil || fmt.Sprint(parsedVal) != value {
t.Error(fmt.Sprintf(NoError, value, parsedVal, err))
}
}
func TestParseInt32Invalid(t *testing.T) {
key := "key"
value := "20asd"
ingress.Annotations[key] = value
parsedVal, err := parseInt32(&ingress, key)
if errors.IsInvalidContent(err) {
t.Error(fmt.Sprintf(Error, err, parsedVal, err))
}
}
func TestParseInt32MissingKey(t *testing.T) {
key := "key"
delete(ingress.Annotations, key)
parsedVal, err := parseInt32(&ingress, key)
if !errors.IsMissingAnnotations(err) || parsedVal != 0 {
t.Error(fmt.Sprintf(Error, errors.ErrMissingAnnotations, parsedVal, err))
}
}
func TestParseString(t *testing.T) {
key := "key"
value := "/path"
ingress.Annotations[key] = value
parsedVal, err := parseString(&ingress, key)
if parsedVal != value || err != nil {
t.Error(fmt.Sprintf(NoError, value, parsedVal, err))
}
}
func TestParseStringMissingKey(t *testing.T) {
key := "key"
delete(ingress.Annotations, key)
parsedVal, err := parseString(&ingress, key)
if !errors.IsMissingAnnotations(err) {
t.Error(fmt.Sprintf(Error, errors.ErrMissingAnnotations, parsedVal, err))
}
}