Bumping k8s dependencies to 1.13

vendor/github.com/go-openapi/swag/util_test.go

@@ -76,22 +76,38 @@ func TestContainsStringsCI(t *testing.T) {
 	assert.False(t, ContainsStringsCI(list, "nuts"))
 }
 
+func TestContainsStrings(t *testing.T) {
+	list := []string{"hello", "world", "and", "such"}
+
+	assert.True(t, ContainsStrings(list, "hello"))
+	assert.False(t, ContainsStrings(list, "hELLo"))
+	assert.True(t, ContainsStrings(list, "world"))
+	assert.False(t, ContainsStrings(list, "World"))
+	assert.True(t, ContainsStrings(list, "and"))
+	assert.False(t, ContainsStrings(list, "AND"))
+	assert.False(t, ContainsStrings(list, "nuts"))
+}
+
+const (
+	collectionFormatComma = "csv"
+)
+
 func TestSplitByFormat(t *testing.T) {
 	expected := []string{"one", "two", "three"}
-	for _, fmt := range []string{"csv", "pipes", "tsv", "ssv", "multi"} {
+	for _, fmt := range []string{collectionFormatComma, collectionFormatPipe, collectionFormatTab, collectionFormatSpace, collectionFormatMulti} {
 
 		var actual []string
 		switch fmt {
-		case "multi":
+		case collectionFormatMulti:
 			assert.Nil(t, SplitByFormat("", fmt))
 			assert.Nil(t, SplitByFormat("blah", fmt))
-		case "ssv":
+		case collectionFormatSpace:
 			actual = SplitByFormat(strings.Join(expected, " "), fmt)
 			assert.EqualValues(t, expected, actual)
-		case "pipes":
+		case collectionFormatPipe:
 			actual = SplitByFormat(strings.Join(expected, "|"), fmt)
 			assert.EqualValues(t, expected, actual)
-		case "tsv":
+		case collectionFormatTab:
 			actual = SplitByFormat(strings.Join(expected, "\t"), fmt)
 			assert.EqualValues(t, expected, actual)
 		default:
@@ -102,18 +118,18 @@ func TestSplitByFormat(t *testing.T) {
 }
 
 func TestJoinByFormat(t *testing.T) {
-	for _, fmt := range []string{"csv", "pipes", "tsv", "ssv", "multi"} {
+	for _, fmt := range []string{collectionFormatComma, collectionFormatPipe, collectionFormatTab, collectionFormatSpace, collectionFormatMulti} {
 
 		lval := []string{"one", "two", "three"}
 		var expected []string
 		switch fmt {
-		case "multi":
+		case collectionFormatMulti:
 			expected = lval
-		case "ssv":
+		case collectionFormatSpace:
 			expected = []string{strings.Join(lval, " ")}
-		case "pipes":
+		case collectionFormatPipe:
 			expected = []string{strings.Join(lval, "|")}
-		case "tsv":
+		case collectionFormatTab:
 			expected = []string{strings.Join(lval, "\t")}
 		default:
 			expected = []string{strings.Join(lval, ",")}
@@ -291,3 +307,69 @@ func TestIsZero(t *testing.T) {
 		assert.Equal(t, it.Expected, IsZero(it.Data), fmt.Sprintf("%#v", it.Data))
 	}
 }
+
+func TestCamelize(t *testing.T) {
+	samples := []translationSample{
+		{"SampleText", "Sampletext"},
+		{"FindThingByID", "Findthingbyid"},
+		{"CAPWD.folwdBylc", "Capwd.folwdbylc"},
+		{"CAPWDfolwdBylc", "Capwdfolwdbylc"},
+		{"CAP_WD_folwdBylc", "Cap_wd_folwdbylc"},
+		{"TypeOAI_alias", "Typeoai_alias"},
+		{"Type_OAI_alias", "Type_oai_alias"},
+		{"Type_OAIAlias", "Type_oaialias"},
+		{"ELB.HTTPLoadBalancer", "Elb.httploadbalancer"},
+		{"elbHTTPLoadBalancer", "Elbhttploadbalancer"},
+		{"ELBHTTPLoadBalancer", "Elbhttploadbalancer"},
+	}
+
+	for _, sample := range samples {
+		res := Camelize(sample.str)
+		assert.Equalf(t, sample.out, res, "expected Camelize(%q)=%q, got %q", sample.str, sample.out, res)
+	}
+}
+
+func TestToHumanNameTitle(t *testing.T) {
+	samples := []translationSample{
+		{"SampleText", "Sample Text"},
+		{"FindThingByID", "Find Thing By ID"},
+		{"CAPWD.folwdBylc", "CAPWD Folwd Bylc"},
+		{"CAPWDfolwdBylc", "Capwdfolwd Bylc"},
+		{"CAP_WD_folwdBylc", "CAP WD Folwd Bylc"},
+		{"TypeOAI_alias", "Type OAI Alias"},
+		{"Type_OAI_alias", "Type OAI Alias"},
+		{"Type_OAIAlias", "Type OAI Alias"},
+		{"ELB.HTTPLoadBalancer", "ELB HTTP Load Balancer"},
+		{"elbHTTPLoadBalancer", "elb HTTP Load Balancer"},
+		{"ELBHTTPLoadBalancer", "ELB HTTP Load Balancer"},
+	}
+
+	for _, sample := range samples {
+		res := ToHumanNameTitle(sample.str)
+		assert.Equalf(t, sample.out, res, "expected ToHumanNameTitle(%q)=%q, got %q", sample.str, sample.out, res)
+	}
+}
+
+func TestToVarName(t *testing.T) {
+	samples := []translationSample{
+		{"SampleText", "sampleText"},
+		{"FindThingByID", "findThingByID"},
+		{"CAPWD.folwdBylc", "cAPWDFolwdBylc"},
+		{"CAPWDfolwdBylc", "capwdfolwdBylc"},
+		{"CAP_WD_folwdBylc", "cAPWDFolwdBylc"},
+		{"TypeOAI_alias", "typeOAIAlias"},
+		{"Type_OAI_alias", "typeOAIAlias"},
+		{"Type_OAIAlias", "typeOAIAlias"},
+		{"ELB.HTTPLoadBalancer", "eLBHTTPLoadBalancer"},
+		{"elbHTTPLoadBalancer", "eLBHTTPLoadBalancer"},
+		{"ELBHTTPLoadBalancer", "eLBHTTPLoadBalancer"},
+		{"Id", "id"},
+		{"HTTP", "http"},
+		{"A", "a"},
+	}
+
+	for _, sample := range samples {
+		res := ToVarName(sample.str)
+		assert.Equalf(t, sample.out, res, "expected ToVarName(%q)=%q, got %q", sample.str, sample.out, res)
+	}
+}