github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-26 05:03:09 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #40882 from apprenda/kubeadm_util_tests

Browse Source 
Automatic merge from submit-queue (batch tested with PRs 41064, 41090, 41068, 41073, 40882)

kubeadm: updated tests in app/util pkg

**What this PR does / why we need it**: Tests did not follow the standard of being table driven. Updated to make future changes (Adding/deleting tests) easier as well as more readable

Adding unit tests is a WIP from #34136

**Special notes for your reviewer**: /cc @luxas @pires 

**Release note**:
```release-note
NONE
```
This commit is contained in:
Kubernetes Submit Queue 2017-02-07 13:46:41 -08:00 committed by GitHub
commit 3ce49346a7
1 changed files with 73 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
cmd/kubeadm/app/util/tokens_test.go
View File

@ -23,92 +23,95 @@ import (
) )
func TestTokenParse(t *testing.T) { func TestTokenParse(t *testing.T) {
invalidTokens := []string{ var tests = []struct {
// invalid parcel size token string
"1234567890123456789012", expected bool
"12345:1234567890123456", }{
".1234567890123456", {token: "1234567890123456789012", expected: false}, // invalid parcel size
// invalid separation {token: "12345:1234567890123456", expected: false}, // invalid parcel size
"123456:1234567890.123456", {token: ".1234567890123456", expected: false}, // invalid parcel size
"abcdef.1234567890123456", {token: "123456:1234567890.123456", expected: false}, // invalid separation
// invalid token id {token: "abcdef.1234567890123456", expected: false}, // invalid separation
"Abcdef:1234567890123456", {token: "Abcdef:1234567890123456", expected: false}, // invalid token id
// invalid token secret {token: "123456:AABBCCDDEEFFGGHH", expected: false}, // invalid token secret
"123456:AABBCCDDEEFFGGHH", {token: "abcdef:1234567890123456", expected: true},
{token: "123456:aabbccddeeffgghh", expected: true},
} }
for _, token := range invalidTokens { for _, rt := range tests {
if _, _, err := ParseToken(token); err == nil { _, _, actual := ParseToken(rt.token)
t.Errorf("ParseToken did not return an error for this invalid token: [%s]", token) if (actual == nil) != rt.expected {
t.Errorf(
"failed ParseToken for this token: [%s]\n\texpected: %t\n\t actual: %t",
rt.token,
rt.expected,
(actual == nil),
)
} }
} }
validTokens := []string{
"abcdef:1234567890123456",
"123456:aabbccddeeffgghh",
}
for _, token := range validTokens {
if _, _, err := ParseToken(token); err != nil {
t.Errorf("ParseToken returned an error for this valid token: [%s]", token)
}
}
} }
func TestParseTokenID(t *testing.T) { func TestParseTokenID(t *testing.T) {
invalidTokenIDs := []string{ var tests = []struct {
"", tokenID string
"1234567890123456789012", expected bool
"12345", }{
"Abcdef", {tokenID: "", expected: false},
{tokenID: "1234567890123456789012", expected: false},
{tokenID: "12345", expected: false},
{tokenID: "Abcdef", expected: false},
{tokenID: "abcdef", expected: true},
{tokenID: "123456", expected: true},
} }
for _, rt := range tests {
for _, tokenID := range invalidTokenIDs { actual := ParseTokenID(rt.tokenID)
if err := ParseTokenID(tokenID); err == nil { if (actual == nil) != rt.expected {
t.Errorf("ParseTokenID did not return an error for this invalid token ID: [%q]", tokenID) t.Errorf(
} "failed ParseTokenID for this token ID: [%s]\n\texpected: %t\n\t actual: %t",
} rt.tokenID,
rt.expected,
validTokens := []string{ (actual == nil),
"abcdef", )
"123456",
}
for _, tokenID := range validTokens {
if err := ParseTokenID(tokenID); err != nil {
t.Errorf("ParseTokenID failed for a valid token ID [%q], err: %+v", tokenID, err)
} }
} }
} }
func TestValidateToken(t *testing.T) { func TestValidateToken(t *testing.T) {
invalidTokens := []*kubeadmapi.TokenDiscovery{ var tests = []struct {
{ID: "", Secret: ""}, token *kubeadmapi.TokenDiscovery
{ID: "1234567890123456789012", Secret: ""}, expected bool
{ID: "", Secret: "1234567890123456789012"}, }{
{ID: "12345", Secret: "1234567890123456"}, {token: &kubeadmapi.TokenDiscovery{ID: "", Secret: ""}, expected: false},
{ID: "Abcdef", Secret: "1234567890123456"}, {token: &kubeadmapi.TokenDiscovery{ID: "1234567890123456789012", Secret: ""}, expected: false},
{ID: "123456", Secret: "AABBCCDDEEFFGGHH"}, {token: &kubeadmapi.TokenDiscovery{ID: "", Secret: "1234567890123456789012"}, expected: false},
{ID: "abc*ef", Secret: "1234567890123456"}, {token: &kubeadmapi.TokenDiscovery{ID: "12345", Secret: "1234567890123456"}, expected: false},
{ID: "abcdef", Secret: "123456789*123456"}, {token: &kubeadmapi.TokenDiscovery{ID: "Abcdef", Secret: "1234567890123456"}, expected: false},
{token: &kubeadmapi.TokenDiscovery{ID: "123456", Secret: "AABBCCDDEEFFGGHH"}, expected: false},
{token: &kubeadmapi.TokenDiscovery{ID: "abc*ef", Secret: "1234567890123456"}, expected: false},
{token: &kubeadmapi.TokenDiscovery{ID: "abcdef", Secret: "123456789*123456"}, expected: false},
{token: &kubeadmapi.TokenDiscovery{ID: "abcdef", Secret: "1234567890123456"}, expected: true},
{token: &kubeadmapi.TokenDiscovery{ID: "123456", Secret: "aabbccddeeffgghh"}, expected: true},
{token: &kubeadmapi.TokenDiscovery{ID: "abc456", Secret: "1234567890123456"}, expected: true},
{token: &kubeadmapi.TokenDiscovery{ID: "abcdef", Secret: "123456ddeeffgghh"}, expected: true},
} }
for _, rt := range tests {
for _, token := range invalidTokens { valid, actual := ValidateToken(rt.token)
if valid, err := ValidateToken(token); valid == true || err == nil { if (actual == nil) != rt.expected {
t.Errorf("ValidateToken did not return an error for this invalid token: [%s]", token) t.Errorf(
"failed ValidateToken for this token ID: [%s]\n\texpected: %t\n\t actual: %t",
rt.token,
rt.expected,
(actual == nil),
)
} }
} if (valid == true) != rt.expected {
t.Errorf(
validTokens := []*kubeadmapi.TokenDiscovery{ "failed ValidateToken for this token ID: [%s]\n\texpected: %t\n\t actual: %t",
{ID: "abcdef", Secret: "1234567890123456"}, rt.token,
{ID: "123456", Secret: "aabbccddeeffgghh"}, rt.expected,
{ID: "abc456", Secret: "1234567890123456"}, (actual == nil),
{ID: "abcdef", Secret: "123456ddeeffgghh"}, )
}
for _, token := range validTokens {
if valid, err := ValidateToken(token); valid == false || err != nil {
t.Errorf("ValidateToken failed for a valid token [%s], valid: %t, err: %+v", token, valid, err)
} }
} }
} }