github.com/jenkins-x/jx/v2@v2.1.155/pkg/auth/user_auth_test.go (about)

     1  // +build unit
     2  
     3  package auth_test
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/jenkins-x/jx/v2/pkg/auth"
     9  	"github.com/jenkins-x/jx/v2/pkg/util"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func setEnvs(t *testing.T, envs map[string]string) {
    14  	err := util.RestoreEnviron(envs)
    15  	assert.NoError(t, err, "should set the environment variables")
    16  }
    17  
    18  func cleanEnvs(t *testing.T, envs []string) {
    19  	_, err := util.GetAndCleanEnviron(envs)
    20  	assert.NoError(t, err, "shuold clean the environment variables")
    21  }
    22  
    23  func TestCreateAuthUserFromEnvironment(t *testing.T) {
    24  	const prefix = "TEST"
    25  	tests := map[string]struct {
    26  		prefix  string
    27  		setup   func(t *testing.T)
    28  		cleanup func(t *testing.T)
    29  		want    auth.UserAuth
    30  	}{
    31  		"create auth user from environment with api token": {
    32  			prefix: prefix,
    33  			setup: func(t *testing.T) {
    34  				setEnvs(t, map[string]string{
    35  					auth.UsernameEnv(prefix): "test",
    36  					auth.ApiTokenEnv(prefix): "test",
    37  				})
    38  			},
    39  			cleanup: func(t *testing.T) {
    40  				cleanEnvs(t, []string{
    41  					auth.UsernameEnv(prefix),
    42  					auth.ApiTokenEnv(prefix),
    43  				})
    44  			},
    45  			want: auth.UserAuth{
    46  				Username:    "test",
    47  				ApiToken:    "test",
    48  				BearerToken: "",
    49  				Password:    "",
    50  			},
    51  		},
    52  		"create auth user from environment with bearer token": {
    53  			prefix: prefix,
    54  			setup: func(t *testing.T) {
    55  				setEnvs(t, map[string]string{
    56  					auth.UsernameEnv(prefix):    "test",
    57  					auth.BearerTokenEnv(prefix): "test",
    58  				})
    59  			},
    60  			cleanup: func(t *testing.T) {
    61  				cleanEnvs(t, []string{
    62  					auth.UsernameEnv(prefix),
    63  					auth.BearerTokenEnv(prefix),
    64  				})
    65  			},
    66  			want: auth.UserAuth{
    67  				Username:    "test",
    68  				ApiToken:    "",
    69  				BearerToken: "test",
    70  				Password:    "",
    71  			},
    72  		},
    73  		"create auth user from environment with default name": {
    74  			prefix: prefix,
    75  			setup: func(t *testing.T) {
    76  				setEnvs(t, map[string]string{
    77  					auth.ApiTokenEnv(prefix): "test",
    78  				})
    79  			},
    80  			cleanup: func(t *testing.T) {
    81  				cleanEnvs(t, []string{
    82  					auth.ApiTokenEnv(prefix),
    83  				})
    84  			},
    85  			want: auth.UserAuth{
    86  				Username:    auth.DefaultUsername,
    87  				ApiToken:    "test",
    88  				BearerToken: "",
    89  				Password:    "",
    90  			},
    91  		},
    92  	}
    93  
    94  	for name, tc := range tests {
    95  		t.Run(name, func(t *testing.T) {
    96  			if tc.setup != nil {
    97  				tc.setup(t)
    98  			}
    99  
   100  			user := auth.CreateAuthUserFromEnvironment(prefix)
   101  			assert.Equal(t, tc.want, user)
   102  
   103  			if tc.cleanup != nil {
   104  				tc.cleanup(t)
   105  			}
   106  		})
   107  	}
   108  }
   109  
   110  func TestIsInvalid(t *testing.T) {
   111  	tests := map[string]struct {
   112  		user *auth.UserAuth
   113  		want bool
   114  	}{
   115  		"invalid user when empty": {
   116  			user: &auth.UserAuth{},
   117  			want: true,
   118  		},
   119  		"invalid user with only a username": {
   120  			user: &auth.UserAuth{
   121  				Username: "test",
   122  			},
   123  			want: true,
   124  		},
   125  		"invalid user with only a api token": {
   126  			user: &auth.UserAuth{
   127  				ApiToken: "test",
   128  			},
   129  			want: true,
   130  		},
   131  		"valid user with only a bearer token": {
   132  			user: &auth.UserAuth{
   133  				BearerToken: "test",
   134  			},
   135  			want: false,
   136  		},
   137  		"valid user with api token": {
   138  			user: &auth.UserAuth{
   139  				Username: "test",
   140  				ApiToken: "test",
   141  			},
   142  			want: false,
   143  		},
   144  		"valid user with bearer token": {
   145  			user: &auth.UserAuth{
   146  				Username:    "test",
   147  				BearerToken: "test",
   148  			},
   149  			want: false,
   150  		},
   151  		"valid user with api token and bearer token": {
   152  			user: &auth.UserAuth{
   153  				Username:    "test",
   154  				ApiToken:    "test",
   155  				BearerToken: "test",
   156  			},
   157  			want: false,
   158  		},
   159  	}
   160  
   161  	for name, tc := range tests {
   162  		t.Run(name, func(t *testing.T) {
   163  			result := tc.user.IsInvalid()
   164  			msg := ""
   165  			if tc.want {
   166  				msg = "user should be invalid"
   167  			} else {
   168  				msg = "user should be valid"
   169  			}
   170  			assert.Equalf(t, tc.want, result, msg)
   171  		})
   172  	}
   173  }