user_test.go

Documentation: os/user

		 1  // Copyright 2011 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package user
		 6  
		 7  import (
		 8  	"runtime"
		 9  	"testing"
		10  )
		11  
		12  func checkUser(t *testing.T) {
		13  	t.Helper()
		14  	if !userImplemented {
		15  		t.Skip("user: not implemented; skipping tests")
		16  	}
		17  }
		18  
		19  func TestCurrent(t *testing.T) {
		20  	u, err := Current()
		21  	if err != nil {
		22  		t.Fatalf("Current: %v (got %#v)", err, u)
		23  	}
		24  	if u.HomeDir == "" {
		25  		t.Errorf("didn't get a HomeDir")
		26  	}
		27  	if u.Username == "" {
		28  		t.Errorf("didn't get a username")
		29  	}
		30  }
		31  
		32  func BenchmarkCurrent(b *testing.B) {
		33  	for i := 0; i < b.N; i++ {
		34  		Current()
		35  	}
		36  }
		37  
		38  func compare(t *testing.T, want, got *User) {
		39  	if want.Uid != got.Uid {
		40  		t.Errorf("got Uid=%q; want %q", got.Uid, want.Uid)
		41  	}
		42  	if want.Username != got.Username {
		43  		t.Errorf("got Username=%q; want %q", got.Username, want.Username)
		44  	}
		45  	if want.Name != got.Name {
		46  		t.Errorf("got Name=%q; want %q", got.Name, want.Name)
		47  	}
		48  	if want.HomeDir != got.HomeDir {
		49  		t.Errorf("got HomeDir=%q; want %q", got.HomeDir, want.HomeDir)
		50  	}
		51  	if want.Gid != got.Gid {
		52  		t.Errorf("got Gid=%q; want %q", got.Gid, want.Gid)
		53  	}
		54  }
		55  
		56  func TestLookup(t *testing.T) {
		57  	checkUser(t)
		58  
		59  	if runtime.GOOS == "plan9" {
		60  		t.Skipf("Lookup not implemented on %q", runtime.GOOS)
		61  	}
		62  
		63  	want, err := Current()
		64  	if err != nil {
		65  		t.Fatalf("Current: %v", err)
		66  	}
		67  	// TODO: Lookup() has a fast path that calls Current() and returns if the
		68  	// usernames match, so this test does not exercise very much. It would be
		69  	// good to try and test finding a different user than the current user.
		70  	got, err := Lookup(want.Username)
		71  	if err != nil {
		72  		t.Fatalf("Lookup: %v", err)
		73  	}
		74  	compare(t, want, got)
		75  }
		76  
		77  func TestLookupId(t *testing.T) {
		78  	checkUser(t)
		79  
		80  	if runtime.GOOS == "plan9" {
		81  		t.Skipf("LookupId not implemented on %q", runtime.GOOS)
		82  	}
		83  
		84  	want, err := Current()
		85  	if err != nil {
		86  		t.Fatalf("Current: %v", err)
		87  	}
		88  	got, err := LookupId(want.Uid)
		89  	if err != nil {
		90  		t.Fatalf("LookupId: %v", err)
		91  	}
		92  	compare(t, want, got)
		93  }
		94  
		95  func checkGroup(t *testing.T) {
		96  	t.Helper()
		97  	if !groupImplemented {
		98  		t.Skip("user: group not implemented; skipping test")
		99  	}
	 100  }
	 101  
	 102  func TestLookupGroup(t *testing.T) {
	 103  	checkGroup(t)
	 104  	user, err := Current()
	 105  	if err != nil {
	 106  		t.Fatalf("Current(): %v", err)
	 107  	}
	 108  
	 109  	g1, err := LookupGroupId(user.Gid)
	 110  	if err != nil {
	 111  		// NOTE(rsc): Maybe the group isn't defined. That's fine.
	 112  		// On my OS X laptop, rsc logs in with group 5000 even
	 113  		// though there's no name for group 5000. Such is Unix.
	 114  		t.Logf("LookupGroupId(%q): %v", user.Gid, err)
	 115  		return
	 116  	}
	 117  	if g1.Gid != user.Gid {
	 118  		t.Errorf("LookupGroupId(%q).Gid = %s; want %s", user.Gid, g1.Gid, user.Gid)
	 119  	}
	 120  
	 121  	g2, err := LookupGroup(g1.Name)
	 122  	if err != nil {
	 123  		t.Fatalf("LookupGroup(%q): %v", g1.Name, err)
	 124  	}
	 125  	if g1.Gid != g2.Gid || g1.Name != g2.Name {
	 126  		t.Errorf("LookupGroup(%q) = %+v; want %+v", g1.Name, g2, g1)
	 127  	}
	 128  }
	 129  
	 130  func TestGroupIds(t *testing.T) {
	 131  	checkGroup(t)
	 132  	if runtime.GOOS == "aix" {
	 133  		t.Skip("skipping GroupIds, see golang.org/issue/30563")
	 134  	}
	 135  	if runtime.GOOS == "illumos" {
	 136  		t.Skip("skipping GroupIds, see golang.org/issue/14709")
	 137  	}
	 138  	user, err := Current()
	 139  	if err != nil {
	 140  		t.Fatalf("Current(): %v", err)
	 141  	}
	 142  	gids, err := user.GroupIds()
	 143  	if err != nil {
	 144  		t.Fatalf("%+v.GroupIds(): %v", user, err)
	 145  	}
	 146  	if !containsID(gids, user.Gid) {
	 147  		t.Errorf("%+v.GroupIds() = %v; does not contain user GID %s", user, gids, user.Gid)
	 148  	}
	 149  }
	 150  
	 151  func containsID(ids []string, id string) bool {
	 152  	for _, x := range ids {
	 153  		if x == id {
	 154  			return true
	 155  		}
	 156  	}
	 157  	return false
	 158  }
	 159
View as plain text