Repository navigation
Expand file tree
/
Copy pathutil_test.go
More file actions
164 lines (147 loc) · 5.42 KB
/
Copy pathutil_test.go
File metadata and controls
164 lines (147 loc) · 5.42 KB
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
package main
import (
"testing"
)
func TestValidateIdentifier(t *testing.T) {
tests := []struct {
name string
identifier string
identifierType string
expectError bool
}{
// Valid cases
{"valid alphanumeric", "satellite1", "satellite name", false},
{"valid with hyphen", "my-satellite", "satellite name", false},
{"valid with underscore", "my_satellite", "satellite name", false},
{"valid with dot", "my.satellite", "satellite name", false},
{"valid mixed", "sat-1_test.prod", "satellite name", false},
{"valid single char", "a", "satellite name", false},
{"valid number", "1", "satellite name", false},
// Invalid cases - empty
{"empty string", "", "satellite name", true},
// Invalid cases - too long
{"too long", "a" + string(make([]byte, 255)), "satellite name", true},
// Invalid cases - invalid characters
{"with spaces", "my satellite", "satellite name", true},
{"with special chars", "sat@llite", "satellite name", true},
{"with slash", "sat/lite", "satellite name", true},
{"with backslash", "sat\\lite", "satellite name", true},
{"with semicolon", "sat;lite", "satellite name", true},
{"with ampersand", "sat&lite", "satellite name", true},
{"with pipe", "sat|lite", "satellite name", true},
// Invalid cases - starting/ending with special chars
{"starting with hyphen", "-satellite", "satellite name", true},
{"ending with hyphen", "satellite-", "satellite name", true},
{"starting with underscore", "_satellite", "satellite name", true},
{"ending with underscore", "satellite_", "satellite name", true},
{"starting with dot", ".satellite", "satellite name", true},
{"ending with dot", "satellite.", "satellite name", true},
// Edge cases
{"all numbers", "12345", "satellite name", false},
{"alphanumeric uppercase", "SATELLITE1", "satellite name", false},
{"mixed case", "SaTeLLiTe", "satellite name", false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := ValidateIdentifier(tt.identifier, tt.identifierType)
if tt.expectError && err == nil {
t.Errorf("ValidateIdentifier(%q, %q) expected error but got none", tt.identifier, tt.identifierType)
}
if !tt.expectError && err != nil {
t.Errorf("ValidateIdentifier(%q, %q) unexpected error: %v", tt.identifier, tt.identifierType, err)
}
})
}
}
func TestSecureCompareStrings(t *testing.T) {
tests := []struct {
name string
a string
b string
expected bool
}{
// Equal strings - should return true
{"equal empty strings", "", "", true},
{"equal single char", "a", "a", true},
{"equal strings", "secret123", "secret123", true},
{"equal long strings", "this-is-a-very-long-secret-token-12345", "this-is-a-very-long-secret-token-12345", true},
{"equal with special chars", "secret!@#$%", "secret!@#$%", true},
// Different strings - should return false
{"different strings", "secret123", "secret456", false},
{"different length", "secret", "secret123", false},
{"different case", "Secret", "secret", false},
{"empty vs non-empty", "", "secret", false},
{"non-empty vs empty", "secret", "", false},
{"prefix match", "secret", "secret123", false},
{"suffix match", "123secret", "secret", false},
{"one char difference", "secret1", "secret2", false},
// Timing attack scenarios - different lengths and positions
{"different at start", "xsecret", "asecret", false},
{"different at middle", "secxret", "secaret", false},
{"different at end", "secretx", "secreta", false},
{"mostly similar", "secrettoken123", "secrettoken456", false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := SecureCompareStrings(tt.a, tt.b)
if result != tt.expected {
t.Errorf("SecureCompareStrings(%q, %q) = %v, want %v", tt.a, tt.b, result, tt.expected)
}
})
}
}
// TestSecureCompareStringsSymmetry verifies that comparison is symmetric
func TestSecureCompareStringsSymmetry(t *testing.T) {
testPairs := []struct {
a string
b string
}{
{"secret", "secret"},
{"secret1", "secret2"},
{"", ""},
{"a", ""},
}
for _, pair := range testPairs {
resultAB := SecureCompareStrings(pair.a, pair.b)
resultBA := SecureCompareStrings(pair.b, pair.a)
if resultAB != resultBA {
t.Errorf("SecureCompareStrings is not symmetric: (%q, %q) = %v, but (%q, %q) = %v",
pair.a, pair.b, resultAB, pair.b, pair.a, resultBA)
}
}
}
// TestCheckSecret verifies that empty secrets never authenticate
func TestCheckSecret(t *testing.T) {
tests := []struct {
name string
provided string
expected string
want bool
}{
{"both empty", "", "", false},
{"configured empty", "secret", "", false},
{"provided empty", "", "secret", false},
{"match", "secret123", "secret123", true},
{"mismatch", "secret123", "secret456", false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := CheckSecret(tt.provided, tt.expected); got != tt.want {
t.Errorf("CheckSecret(%q, %q) = %v, want %v", tt.provided, tt.expected, got, tt.want)
}
})
}
}
// TestNormalizeNames verifies names are lower-cased to match viper's map keys
func TestNormalizeNames(t *testing.T) {
got := normalizeNames([]string{"Server1", "probe.Example.COM", "lower"})
want := []string{"server1", "probe.example.com", "lower"}
for i := range want {
if got[i] != want[i] {
t.Errorf("normalizeNames()[%d] = %q, want %q", i, got[i], want[i])
}
}
if normalizeNames(nil) != nil {
t.Errorf("normalizeNames(nil) should be nil")
}
}