feat(session): default user override

resolves #447

docs/docs/segment-session.md

@@ -39,8 +39,13 @@ properties below. Only used when a value is set, making the above properties obs
 ## Template Properties
 
 - `.UserName`: `string` - the current user's name
+- `.DefaultUserName`: - the default user name (set with the `POSH_SESSION_DEFAULT_USER` env var or `default_user_name` property)
 - `.ComputerName`: `string` - the current computer's name
 - `.SSHSession`: `boolean` - active SSH session or not
 - `.Root`: `boolean` - are you a root/admin user or not
 
+## Environmnent Variables
+
+- `POSH_SESSION_DEFAULT_USER` - used to override the hardcoded `default_user_name` property
+
 [colors]: /docs/configure#colors

src/segment_session.go

@@ -6,12 +6,14 @@ import (
 )
 
 type session struct {
-	props        *properties
+	props           *properties
-	env          environmentInfo
+	env             environmentInfo
-	UserName     string
+	UserName        string
-	ComputerName string
+	DefaultUserName string
-	SSHSession   bool
+	ComputerName    string
-	Root         bool
+	SSHSession      bool
+	Root            bool
+	templateText    string
 }
 
 const (
@@ -29,12 +31,26 @@ const (
 	SSHIcon Property = "ssh_icon"
 	// DefaultUserName holds the default user of the platform
 	DefaultUserName Property = "default_user_name"
+
+	defaultUserEnvVar = "POSH_SESSION_DEFAULT_USER"
 )
 
 func (s *session) enabled() bool {
 	s.UserName = s.getUserName()
+	s.ComputerName = s.getComputerName()
+	s.SSHSession = s.activeSSHSession()
+	s.DefaultUserName = s.getDefaultUser()
+	segmentTemplate := s.props.getString(SegmentTemplate, "")
+	if segmentTemplate != "" {
+		s.Root = s.env.isRunningAsRoot()
+		template := &textTemplate{
+			Template: segmentTemplate,
+			Context:  s,
+		}
+		s.templateText = template.render()
+		return len(s.templateText) > 0
+	}
 	showDefaultUser := s.props.getBool(DisplayDefault, true)
-	defaultUser := s.props.getString(DefaultUserName, "")
 	if !showDefaultUser && defaultUser == s.UserName {
 		return false
 	}
@@ -51,16 +67,8 @@ func (s *session) init(props *properties, env environmentInfo) {
 }
 
 func (s *session) getFormattedText() string {
-	s.ComputerName = s.getComputerName()
+	if len(s.templateText) > 0 {
-	s.SSHSession = s.activeSSHSession()
+		return s.templateText
-	segmentTemplate := s.props.getString(SegmentTemplate, "")
-	if segmentTemplate != "" {
-		s.Root = s.env.isRunningAsRoot()
-		template := &textTemplate{
-			Template: segmentTemplate,
-			Context:  s,
-		}
-		return template.render()
 	}
 	separator := ""
 	if s.props.getBool(DisplayHost, true) && s.props.getBool(DisplayUser, true) {
@@ -98,6 +106,14 @@ func (s *session) getUserName() string {
 	return username
 }
 
+func (s *session) getDefaultUser() string {
+	user := s.env.getenv(defaultUserEnvVar)
+	if len(user) == 0 {
+		user = s.props.getString(DefaultUserName, "")
+	}
+	return user
+}
+
 func (s *session) activeSSHSession() bool {
 	keys := []string{
 		"SSH_CONNECTION",

src/segment_session_test.go

@@ -14,6 +14,7 @@ type sessionArgs struct {
 	connection        string
 	client            string
 	sshIcon           string
+	defaultUserName   string
 }
 
 func setupSession(args *sessionArgs) session {
@@ -23,6 +24,7 @@ func setupSession(args *sessionArgs) session {
 	env.On("getRuntimeGOOS", nil).Return(args.goos)
 	env.On("getenv", "SSH_CONNECTION").Return(args.connection)
 	env.On("getenv", "SSH_CLIENT").Return(args.client)
+	env.On("getenv", defaultUserEnvVar).Return(args.defaultUserName)
 	props := &properties{
 		values: map[Property]interface{}{
 			UserInfoSeparator: args.userInfoSeparator,
@@ -154,59 +156,89 @@ func TestActiveSSHSessionActiveBoth(t *testing.T) {
 
 func TestSessionSegmentTemplate(t *testing.T) {
 	cases := []struct {
-		Case           string
+		Case            string
-		ExpectedString string
+		ExpectedEnabled bool
-		UserName       string
+		ExpectedString  string
-		ComputerName   string
+		UserName        string
-		SSHSession     bool
+		DefaultUserName string
-		Root           bool
+		ComputerName    string
-		Template       string
+		SSHSession      bool
+		Root            bool
+		Template        string
 	}{
 		{
-			Case:           "user and computer",
+			Case:            "user and computer",
-			ExpectedString: "john@company-laptop",
+			ExpectedString:  "john@company-laptop",
-			ComputerName:   "company-laptop",
+			ComputerName:    "company-laptop",
-			UserName:       "john",
+			UserName:        "john",
-			Template:       "{{.UserName}}{{if .ComputerName}}@{{.ComputerName}}{{end}}",
+			Template:        "{{.UserName}}{{if .ComputerName}}@{{.ComputerName}}{{end}}",
+			ExpectedEnabled: true,
 		},
 		{
-			Case:           "user only",
+			Case:            "user only",
-			ExpectedString: "john",
+			ExpectedString:  "john",
-			UserName:       "john",
+			UserName:        "john",
-			Template:       "{{.UserName}}{{if .ComputerName}}@{{.ComputerName}}{{end}}",
+			Template:        "{{.UserName}}{{if .ComputerName}}@{{.ComputerName}}{{end}}",
+			ExpectedEnabled: true,
 		},
 		{
-			Case:           "user with ssh",
+			Case:            "user with ssh",
-			ExpectedString: "john on remote",
+			ExpectedString:  "john on remote",
-			UserName:       "john",
+			UserName:        "john",
-			SSHSession:     true,
+			SSHSession:      true,
-			ComputerName:   "remote",
+			ComputerName:    "remote",
-			Template:       "{{.UserName}}{{if .SSHSession}} on {{.ComputerName}}{{end}}",
+			Template:        "{{.UserName}}{{if .SSHSession}} on {{.ComputerName}}{{end}}",
+			ExpectedEnabled: true,
 		},
 		{
-			Case:           "user without ssh",
+			Case:            "user without ssh",
-			ExpectedString: "john",
+			ExpectedString:  "john",
-			UserName:       "john",
+			UserName:        "john",
-			SSHSession:     false,
+			SSHSession:      false,
-			ComputerName:   "remote",
+			ComputerName:    "remote",
-			Template:       "{{.UserName}}{{if .SSHSession}} on {{.ComputerName}}{{end}}",
+			Template:        "{{.UserName}}{{if .SSHSession}} on {{.ComputerName}}{{end}}",
+			ExpectedEnabled: true,
 		},
 		{
-			Case:           "user with root and ssh",
+			Case:            "user with root and ssh",
-			ExpectedString: "super john on remote",
+			ExpectedString:  "super john on remote",
-			UserName:       "john",
+			UserName:        "john",
-			SSHSession:     true,
+			SSHSession:      true,
-			ComputerName:   "remote",
+			ComputerName:    "remote",
-			Root:           true,
+			Root:            true,
-			Template:       "{{if .Root}}super {{end}}{{.UserName}}{{if .SSHSession}} on {{.ComputerName}}{{end}}",
+			Template:        "{{if .Root}}super {{end}}{{.UserName}}{{if .SSHSession}} on {{.ComputerName}}{{end}}",
+			ExpectedEnabled: true,
 		},
 		{
-			Case:           "no template",
+			Case:            "no template",
-			ExpectedString: "\uf817 <>john</>@<>remote</>",
+			ExpectedString:  "\uf817 <>john</>@<>remote</>",
-			UserName:       "john",
+			UserName:        "john",
-			SSHSession:     true,
+			SSHSession:      true,
-			ComputerName:   "remote",
+			ComputerName:    "remote",
-			Root:           true,
+			Root:            true,
+			ExpectedEnabled: true,
+		},
+		{
+			Case:            "default user not equal",
+			ExpectedString:  "john",
+			UserName:        "john",
+			DefaultUserName: "jack",
+			SSHSession:      true,
+			ComputerName:    "remote",
+			Root:            true,
+			Template:        "{{if ne .DefaultUserName .UserName}}{{.UserName}}{{end}}",
+			ExpectedEnabled: true,
+		},
+		{
+			Case:            "default user equal",
+			ExpectedString:  "",
+			UserName:        "john",
+			DefaultUserName: "john",
+			SSHSession:      true,
+			ComputerName:    "remote",
+			Root:            true,
+			Template:        "{{if ne .DefaultUserName .UserName}}{{.UserName}}{{end}}",
+			ExpectedEnabled: false,
 		},
 	}
 
@@ -222,6 +254,7 @@ func TestSessionSegmentTemplate(t *testing.T) {
 		env.On("getenv", "SSH_CONNECTION").Return(SSHSession)
 		env.On("getenv", "SSH_CLIENT").Return(SSHSession)
 		env.On("isRunningAsRoot", nil).Return(tc.Root)
+		env.On("getenv", defaultUserEnvVar).Return(tc.DefaultUserName)
 		props := &properties{
 			values: map[Property]interface{}{
 				SegmentTemplate: tc.Template,
@@ -231,7 +264,9 @@ func TestSessionSegmentTemplate(t *testing.T) {
 			env:   env,
 			props: props,
 		}
-		_ = session.enabled()
+		assert.Equal(t, tc.ExpectedEnabled, session.enabled(), tc.Case)
-		assert.Equal(t, tc.ExpectedString, session.string(), tc.Case)
+		if tc.ExpectedEnabled {
+			assert.Equal(t, tc.ExpectedString, session.string(), tc.Case)
+		}
 	}
 }