func TestUserSummary(t *testing.T) {
tc := SetupEngineTest(t, "usersummary")
defer tc.Cleanup()
uids := []keybase1.UID{
libkb.UsernameToUID("t_alice"),
libkb.UsernameToUID("t_bob"),
libkb.UsernameToUID("t_charlie"),
}
eng := NewUserSummary(uids, tc.G)
ctx := &Context{}
if err := RunEngine(eng, ctx); err != nil {
t.Fatal(err)
}
sums := eng.Summaries()
if len(sums) != 3 {
t.Errorf("# summaries: %d, expected 3", len(sums))
}
for _, uid := range uids {
if _, ok := sums[uid]; !ok {
t.Errorf("no summary for %s in result", uid)
}
}
}
// TestTrackerList creates a new fake user and has that user track
// t_alice. It then uses the TrackerList engine to get the
// t_alice's trackers and makes sure that the new fake user is in
// the list.
func TestListTrackers(t *testing.T) {
tc := SetupEngineTest(t, "trackerlist")
defer tc.Cleanup()
fu := CreateAndSignupFakeUser(tc, "login")
trackAlice(tc, fu)
defer untrackAlice(tc, fu)
uid := libkb.UsernameToUID("t_alice")
e := NewListTrackers(uid, tc.G)
ctx := &Context{LogUI: tc.G.UI.GetLogUI()}
if err := RunEngine(e, ctx); err != nil {
t.Fatal(err)
}
buid := libkb.UsernameToUID(fu.Username)
trackers := e.List()
if len(trackers) == 0 {
t.Errorf("t_alice tracker count: 0. expected > 0.")
}
found := false
for _, x := range trackers {
if x.GetUID().Equal(buid) {
found = true
break
}
}
if !found {
t.Errorf("fake user %q (%s) not included in list of t_alice trackers.", fu.Username, buid)
t.Logf("tracker list:")
for i, x := range trackers {
t.Logf("%d: %s, %d, %d", i, x.Tracker, x.Status, x.MTime)
}
}
}
func TestTokenServerInvalid(t *testing.T) {
keyPair, err := libkb.GenerateNaclSigningKeyPair()
if err != nil {
t.Fatal(err)
}
name := libkb.NewNormalizedUsername("dana")
uid := libkb.UsernameToUID(name.String())
expireIn := 10
server := "test"
clientName := "test_client"
clientVersion := "20192"
token := NewToken(uid, name, keyPair.GetKID(), server, expireIn, clientName, clientVersion)
sig, _, err := keyPair.SignToString(token.Bytes())
if err != nil {
t.Fatal(err)
}
_, err = VerifyToken(sig, "nope", testMaxTokenExpireIn)
_, invalid := err.(InvalidTokenServerError)
if !invalid {
t.Fatal(fmt.Errorf("expected invalid token server error"))
}
token, err = VerifyToken(sig, server, testMaxTokenExpireIn)
if err != nil {
t.Fatal(err)
}
if err = checkToken(token, uid, name, keyPair.GetKID(),
server, expireIn, clientName, clientVersion); err != nil {
t.Fatal(err)
}
}
func TestTokenVerifyToken(t *testing.T) {
keyPair, err := libkb.GenerateNaclSigningKeyPair()
if err != nil {
t.Fatal(err)
}
name := libkb.NewNormalizedUsername("alice")
uid := libkb.UsernameToUID(name.String())
expireIn := 10
server := "test"
clientName := "test_client"
clientVersion := "41651"
token := NewToken(uid, name, keyPair.GetKID(), server, expireIn, clientName, clientVersion)
sig, _, err := keyPair.SignToString(token.Bytes())
if err != nil {
t.Fatal(err)
}
_, err = VerifyToken("nope", server, testMaxTokenExpireIn)
if err == nil {
t.Fatal(fmt.Errorf("expected verification failure"))
}
token, err = VerifyToken(sig, server, testMaxTokenExpireIn)
if err != nil {
t.Fatal(err)
}
if err = checkToken(token, uid, name, keyPair.GetKID(),
server, expireIn, clientName, clientVersion); err != nil {
t.Fatal(err)
}
}
func TestMaxExpires(t *testing.T) {
keyPair, err := libkb.GenerateNaclSigningKeyPair()
if err != nil {
t.Fatal(err)
}
name := libkb.NewNormalizedUsername("charlie")
uid := libkb.UsernameToUID(name.String())
expireIn := testMaxTokenExpireIn + 1
server := "test"
clientName := "test_client"
clientVersion := "93021"
challenge, err := GenerateChallenge()
if err != nil {
t.Fatal(err)
}
token := NewToken(uid, name, keyPair.GetKID(), server, challenge,
time.Now().Unix(), expireIn, clientName, clientVersion)
sig, _, err := keyPair.SignToString(token.Bytes())
if err != nil {
t.Fatal(err)
}
_, err = VerifyToken(sig, server, challenge, testMaxTokenExpireIn)
_, maxExpires := err.(MaxTokenExpiresError)
if !maxExpires {
t.Fatal(fmt.Errorf("expected max token expires error"))
}
}
func testKexMeta(t *testing.T, username string, sec *kex.Secret) *kex.Meta {
sendID, err := libkb.NewDeviceID()
if err != nil {
t.Fatal(err)
}
recID, err := libkb.NewDeviceID()
if err != nil {
t.Fatal(err)
}
return &kex.Meta{UID: libkb.UsernameToUID(username), Seqno: 0, StrongID: sec.StrongID(), WeakID: sec.WeakID(), Sender: sendID, Receiver: recID}
}
func newTestUser(nKeys int) *testUser {
un := genUsername()
ret := testUser{
username: libkb.NewNormalizedUsername(un),
uid: libkb.UsernameToUID(un),
keys: make([]keybase1.KID, nKeys),
}
for i := 0; i < nKeys; i++ {
ret.keys[i] = genKID()
}
return &ret
}
func TestTokenExpired(t *testing.T) {
keyPair, err := libkb.GenerateNaclSigningKeyPair()
if err != nil {
t.Fatal(err)
}
name := libkb.NewNormalizedUsername("bob")
uid := libkb.UsernameToUID(name.String())
expireIn := 0
server := "test"
clientName := "test_client"
clientVersion := "21021"
token := NewToken(uid, name, keyPair.GetKID(), server, expireIn, clientName, clientVersion)
sig, _, err := keyPair.SignToString(token.Bytes())
if err != nil {
t.Fatal(err)
}
_, err = VerifyToken(sig, server, testMaxTokenExpireIn)
_, expired := err.(TokenExpiredError)
if !expired {
t.Fatal(fmt.Errorf("expected token expired error"))
}
}
func TestCheckUsers(t *testing.T) {
S, C := newTestSetup()
var users, usersWithDud []keybase1.UID
for i := 0; i < 10; i++ {
u := S.newTestUser(2)
users = append(users, u.uid)
usersWithDud = append(usersWithDud, u.uid)
}
usersWithDud = append(usersWithDud, libkb.UsernameToUID(genUsername()))
if S.numGets != 0 {
t.Fatal("expected 0 gets")
}
err := C.CheckUsers(context.TODO(), users)
if err != nil {
t.Fatal(err)
}
if S.numGets != 10 {
t.Fatal("expected 10 gets")
}
err = C.CheckUsers(context.TODO(), users)
if err != nil {
t.Fatal(err)
}
if S.numGets != 10 {
t.Fatal("expected 10 gets")
}
err = C.CheckUsers(context.TODO(), usersWithDud)
if err == nil {
t.Fatal("Expected an error")
} else if _, ok := err.(userNotFoundError); !ok {
t.Fatal("Expected a user not found error")
}
C.Shutdown()
}