github.com/olli-ai/jx/v2@v2.0.400-0.20210921045218-14731b4dd448/pkg/kube/naming/names_valid_test.go (about)

     1  // +build unit
     2  
     3  package naming_test
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/olli-ai/jx/v2/pkg/kube/naming"
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestToValidName(t *testing.T) {
    13  	t.Parallel()
    14  	assertToValidName(t, "foo", "foo")
    15  	assertToValidName(t, "foo[bot]", "foo-bot")
    16  	assertToValidName(t, "foo-bar", "foo-bar")
    17  	assertToValidName(t, "foo-bar-", "foo-bar")
    18  	assertToValidName(t, "foo-bar-0.1.0", "foo-bar-0-1-0")
    19  	assertToValidName(t, "---foo-bar-", "foo-bar")
    20  	assertToValidName(t, "foo/bar_*123", "foo-bar-123")
    21  	assertToValidName(t, "", "")
    22  }
    23  
    24  func TestToValidValue(t *testing.T) {
    25  	t.Parallel()
    26  	assertToValidValue(t, "1", "1")
    27  	assertToValidValue(t, "1.2.3", "1.2.3")
    28  	assertToValidValue(t, "foo/bar", "foo/bar")
    29  	assertToValidValue(t, "Foo/Bar", "Foo/Bar")
    30  	assertToValidValue(t, "foo", "foo")
    31  	assertToValidValue(t, "foo[bot]", "foo-bot")
    32  	assertToValidValue(t, "foo-bar", "foo-bar")
    33  	assertToValidValue(t, "foo-bar-", "foo-bar")
    34  	assertToValidValue(t, "foo-bar-0.1.0", "foo-bar-0.1.0")
    35  	assertToValidValue(t, "---foo-bar-", "-foo-bar")
    36  	assertToValidValue(t, "foo/bar_*123", "foo/bar-123")
    37  	assertToValidValue(t, "", "")
    38  }
    39  
    40  func TestToValidNameWithDots(t *testing.T) {
    41  	t.Parallel()
    42  	assertToValidNameWithDots(t, "foo-bar-0.1.0", "foo-bar-0.1.0")
    43  	assertToValidNameWithDots(t, "foo/bar_.123", "foo-bar-.123")
    44  }
    45  
    46  func TestToValidNameTruncated(t *testing.T) {
    47  	t.Parallel()
    48  	assertToValidNameTruncated(t, "foo", 7, "foo")
    49  	assertToValidNameTruncated(t, "foo", 3, "foo")
    50  	assertToValidNameTruncated(t, "foo", 2, "fo")
    51  	assertToValidNameTruncated(t, "foo-bar", 4, "foo")
    52  	assertToValidNameTruncated(t, "foo-bar", 5, "foo-b")
    53  	assertToValidNameTruncated(t, "foo-bar-0.1.0", 10, "foo-bar-0")
    54  	assertToValidNameTruncated(t, "---foo-bar-", 10, "foo-bar")
    55  	assertToValidNameTruncated(t, "foo/bar_*123", 11, "foo-bar-123")
    56  }
    57  
    58  func TestToValidGCPServiceAccount(t *testing.T) {
    59  	t.Parallel()
    60  	assertToValidGCPServiceAccount(t, "f", "f-jx-[-a-z0-9]")
    61  	assertToValidGCPServiceAccount(t, "foo", "foo-jx-[-a-z0-9]")
    62  	assertToValidGCPServiceAccount(t, "fo-ko", "fo-ko-jx-[-a-z0-9]")
    63  	assertToValidGCPServiceAccount(t, "foo-ko", "foo-ko")
    64  	assertToValidGCPServiceAccount(t, "foo-bar", "foo-bar")
    65  	assertToValidGCPServiceAccount(t, "foo-bar-0.1.0", "foo-bar-0")
    66  	assertToValidGCPServiceAccount(t, "---foo-bar-", "foo-bar")
    67  	assertToValidGCPServiceAccount(t, "foo/bar_*123", "foo-bar-123")
    68  }
    69  
    70  func assertToValidNameWithDots(t *testing.T, input string, expected string) {
    71  	actual := naming.ToValidNameWithDots(input)
    72  	assert.Equal(t, expected, actual, "ToValidNameWithDots for input %s", input)
    73  }
    74  
    75  func assertToValidName(t *testing.T, input string, expected string) {
    76  	actual := naming.ToValidName(input)
    77  	assert.Equal(t, expected, actual, "ToValidName for input %s", input)
    78  }
    79  
    80  func assertToValidValue(t *testing.T, input string, expected string) {
    81  	actual := naming.ToValidValue(input)
    82  	assert.Equal(t, expected, actual, "ToValidValue for input %s", input)
    83  }
    84  
    85  func assertToValidNameTruncated(t *testing.T, input string, maxLength int, expected string) {
    86  	actual := naming.ToValidNameTruncated(input, maxLength)
    87  	assert.Equal(t, expected, actual, "ToValidNameTruncated for input %s", input)
    88  }
    89  
    90  func assertToValidGCPServiceAccount(t *testing.T, input string, expected string) {
    91  	actual := naming.ToValidGCPServiceAccount(input)
    92  	assert.Regexp(t, expected, actual, "ToValidGCPServiceAccount for input %s", input)
    93  	assert.Regexp(t, "[a-z]([-a-z0-9]*[a-z0-9])", actual, "GCP SA valid regex for input %s", input)
    94  	assert.Regexp(t, "[-a-z0-9]{6,30}", actual, "GCP SA length for input %s", input)
    95  }