make UpdatePassword() and UpdateLogin() work w/ tests

Author: bgentry

netrc/netrc.go

@@ -88,30 +88,58 @@ func (n *Netrc) NewMachine(name, login, password, account string) *Machine {
 		Account:  account,
 
 		nametoken: &token{
-			kind:    tkMachine,
-			rawkind: []byte("\nmachine"),
-			value:   name,
+			kind:     tkMachine,
+			rawkind:  []byte("\nmachine"),
+			value:    name,
+			rawvalue: []byte(" " + name),
 		},
 		logintoken: &token{
-			kind:    tkLogin,
-			rawkind: []byte("\n\tlogin"),
-			value:   login,
+			kind:     tkLogin,
+			rawkind:  []byte("\n\tlogin"),
+			value:    login,
+			rawvalue: []byte(" " + login),
 		},
 		passtoken: &token{
-			kind:    tkPassword,
-			rawkind: []byte("\n\tpassword"),
-			value:   password,
+			kind:     tkPassword,
+			rawkind:  []byte("\n\tpassword"),
+			value:    password,
+			rawvalue: []byte(" " + password),
 		},
 		accounttoken: &token{
-			kind:    tkAccount,
-			rawkind: []byte("\n\taccount"),
-			value:   account,
+			kind:     tkAccount,
+			rawkind:  []byte("\n\taccount"),
+			value:    account,
+			rawvalue: []byte(" " + account),
 		},
 	}
+	n.insertMachineTokensBeforeDefault(m)
 	n.machines = append(n.machines, m)
 	return m
 }
 
+func (n *Netrc) insertMachineTokensBeforeDefault(m *Machine) {
+	newtokens := []*token{m.nametoken}
+	if m.logintoken.value != "" {
+		newtokens = append(newtokens, m.logintoken)
+	}
+	if m.passtoken.value != "" {
+		newtokens = append(newtokens, m.passtoken)
+	}
+	if m.accounttoken.value != "" {
+		newtokens = append(newtokens, m.accounttoken)
+	}
+	for i := range n.tokens {
+		if n.tokens[i].kind == tkDefault {
+			// found the default, now insert tokens before it
+			n.tokens = append(n.tokens[:i], append(newtokens, n.tokens[i:]...)...)
+			return
+		}
+	}
+	// didn't find a default, just add the newtokens to the end
+	n.tokens = append(n.tokens, newtokens...)
+	return
+}
+
 // Machine contains information about a remote machine.
 type Machine struct {
 	Name     string
@@ -127,21 +155,29 @@ type Machine struct {
 
 // UpdatePassword sets the password for the Machine m.
 func (m *Machine) UpdatePassword(newpass string) error {
-	if len(newpass) == 0 {
-		return fmt.Errorf("newpass must be at least 1 letter")
-	}
 	m.Password = newpass
-	oldpass := m.passtoken.value
-	m.passtoken.value = newpass
-	newraw := make([]byte, len(m.passtoken.rawvalue))
-	copy(newraw, m.passtoken.rawvalue)
-	m.passtoken.rawvalue = append(
-		bytes.TrimSuffix(newraw, []byte(oldpass)),
-		[]byte(newpass)...,
-	)
+	updateTokenValue(m.passtoken, newpass)
+	return nil
+}
+
+// UpdateLogin sets the login for the Machine m.
+func (m *Machine) UpdateLogin(newlogin string) error {
+	m.Login = newlogin
+	updateTokenValue(m.logintoken, newlogin)
 	return nil
 }
 
+func updateTokenValue(t *token, value string) {
+	oldvalue := t.value
+	t.value = value
+	newraw := make([]byte, len(t.rawvalue))
+	copy(newraw, t.rawvalue)
+	t.rawvalue = append(
+		bytes.TrimSuffix(newraw, []byte(oldvalue)),
+		[]byte(value)...,
+	)
+}
+
 // Macros contains all the macro definitions in a netrc file.
 type Macros map[string]string
 

netrc/netrc_test.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"io"
 	"io/ioutil"
+	"strings"
 	"testing"
 )
 
@@ -192,6 +193,16 @@ func TestNewMachine(t *testing.T) {
 	loginVal := "dodging-samurai-42@heroku.com"
 	passwordVal := "octocatdodgeballchampions"
 	accountVal := "someacct"
+
+	// sanity check
+	bodyb, _ := n.MarshalText()
+	body := string(bodyb)
+	for _, value := range []string{nameVal, loginVal, passwordVal, accountVal} {
+		if strings.Contains(body, value) {
+			t.Errorf("MarshalText() before NewMachine() contained unexpected %q", value)
+		}
+	}
+
 	m := n.NewMachine(nameVal, loginVal, passwordVal, accountVal)
 	if m == nil {
 		t.Fatalf("NewMachine() returned nil")
@@ -214,6 +225,14 @@ func TestNewMachine(t *testing.T) {
 	checkToken(t, "logintoken", m.logintoken, tkLogin, "\n\tlogin", loginVal)
 	checkToken(t, "passtoken", m.passtoken, tkPassword, "\n\tpassword", passwordVal)
 	checkToken(t, "accounttoken", m.accounttoken, tkAccount, "\n\taccount", accountVal)
+	// check marshal output
+	bodyb, _ = n.MarshalText()
+	body = string(bodyb)
+	for _, value := range []string{nameVal, loginVal, passwordVal, accountVal} {
+		if !strings.Contains(body, value) {
+			t.Errorf("MarshalText() after NewMachine() did not include %q as expected", value)
+		}
+	}
 }
 
 func checkToken(t *testing.T, name string, tok *token, kind tkType, rawkind, value string) {
@@ -243,6 +262,71 @@ type tokenss struct {
 	rawvalue  []byte
 }
 
+func TestUpdateLogin(t *testing.T) {
+	n, err := ParseFile("examples/good.netrc")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tests := []struct {
+		exists   bool
+		name     string
+		oldlogin string
+		newlogin string
+	}{
+		{true, "mail.google.com", "joe@gmail.com", "joe2@gmail.com"},
+		{false, "heroku.com", "", "dodging-samurai-42@heroku.com"},
+	}
+
+	bodyb, _ := n.MarshalText()
+	body := string(bodyb)
+	for _, test := range tests {
+		if strings.Contains(body, test.newlogin) {
+			t.Errorf("MarshalText() before UpdateLogin() contained unexpected %q", test.newlogin)
+		}
+	}
+
+	for _, test := range tests {
+		m, def, err := n.FindMachine(test.name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if def == test.exists {
+			t.Errorf("expected machine %s to not exist, but it did", test.name)
+		} else {
+			if !test.exists {
+				m = n.NewMachine(test.name, test.newlogin, "", "")
+			}
+			if m == nil {
+				t.Errorf("machine %s was nil", test.name)
+				continue
+			}
+			m.UpdateLogin(test.newlogin)
+			m, _, err := n.FindMachine(test.name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if m.Login != test.newlogin {
+				t.Errorf("expected new login %q, got %q", test.newlogin, m.Login)
+			}
+			if m.logintoken.value != test.newlogin {
+				t.Errorf("expected m.logintoken %q, got %q", test.newlogin, m.logintoken.value)
+			}
+		}
+	}
+
+	bodyb, _ = n.MarshalText()
+	body = string(bodyb)
+	for _, test := range tests {
+		if test.exists && strings.Contains(body, test.oldlogin) {
+			t.Errorf("MarshalText() after UpdateLogin() contained unexpected %q", test.oldlogin)
+		}
+		if !strings.Contains(body, test.newlogin) {
+			t.Errorf("MarshalText after UpdatePassword did not contain %q as expected", test.newlogin)
+		}
+	}
+}
+
 func TestUpdatePassword(t *testing.T) {
 	n, err := ParseFile("examples/good.netrc")
 	if err != nil {
@@ -252,11 +336,22 @@ func TestUpdatePassword(t *testing.T) {
 	tests := []struct {
 		exists      bool
 		name        string
-		newlogin    string
+		oldpassword string
 		newpassword string
 	}{
-		{true, "ray", "joe2@gmail.com", "supernewpass"},
-		{false, "heroku.com", "dodging-samurai-42@heroku.com", "octocatdodgeballchampions"},
+		{true, "ray", "mypassword", "supernewpass"},
+		{false, "heroku.com", "", "octocatdodgeballchampions"},
+	}
+
+	bodyb, _ := n.MarshalText()
+	body := string(bodyb)
+	for _, test := range tests {
+		if test.exists && !strings.Contains(body, test.oldpassword) {
+			t.Errorf("MarshalText() before UpdatePassword() did not include %q as expected", test.oldpassword)
+		}
+		if strings.Contains(body, test.newpassword) {
+			t.Errorf("MarshalText() before UpdatePassword() contained unexpected %q", test.newpassword)
+		}
 	}
 
 	for _, test := range tests {
@@ -268,7 +363,7 @@ func TestUpdatePassword(t *testing.T) {
 			t.Errorf("expected machine %s to not exist, but it did", test.name)
 		} else {
 			if !test.exists {
-				m = n.NewMachine(test.name, test.newlogin, test.newpassword, "")
+				m = n.NewMachine(test.name, "", test.newpassword, "")
 			}
 			if m == nil {
 				t.Errorf("machine %s was nil", test.name)
@@ -287,6 +382,17 @@ func TestUpdatePassword(t *testing.T) {
 			}
 		}
 	}
+
+	bodyb, _ = n.MarshalText()
+	body = string(bodyb)
+	for _, test := range tests {
+		if test.exists && strings.Contains(body, test.oldpassword) {
+			t.Errorf("MarshalText() after UpdatePassword() contained unexpected %q", test.oldpassword)
+		}
+		if !strings.Contains(body, test.newpassword) {
+			t.Errorf("MarshalText() after UpdatePassword() did not contain %q as expected", test.newpassword)
+		}
+	}
 }
 
 func netrcReader(filename string, t *testing.T) io.Reader {