Refactoring the user management integration tests

integration/auth/auth_test.go

@@ -47,128 +47,118 @@ func TestMain(m *testing.M) {
 		os.Exit(0)
 	}
 
-	ctx := context.Background()
-	app, err := internal.NewTestApp(ctx, nil)
+	app, err := internal.NewTestApp(context.Background(), nil)
 	if err != nil {
 		log.Fatalln(err)
 	}
-
-	client, err = app.Auth(ctx)
+	client, err = app.Auth(context.Background())
 	if err != nil {
 		log.Fatalln(err)
 	}
 	os.Exit(m.Run())
 }
 
 func TestCustomToken(t *testing.T) {
-	ct, err := client.CustomToken(context.Background(), "user1")
+	uid := randomUID()
+	ct, err := client.CustomToken(context.Background(), uid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	idt, err := signInWithCustomToken(ct)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer deleteUser(uid)
+
+	vt, err := client.VerifyIDToken(context.Background(), idt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if vt.UID != uid {
+		t.Errorf("UID = %q; want UID = %q", vt.UID, uid)
+	}
+}
 
+func TestCustomTokenWithClaims(t *testing.T) {
+	uid := randomUID()
+	ct, err := client.CustomTokenWithClaims(context.Background(), uid, map[string]interface{}{
+		"premium": true,
+		"package": "gold",
+	})
 	if err != nil {
 		t.Fatal(err)
 	}
+
 	idt, err := signInWithCustomToken(ct)
 	if err != nil {
 		t.Fatal(err)
 	}
+	defer deleteUser(uid)
 
 	vt, err := client.VerifyIDToken(context.Background(), idt)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if vt.UID != "user1" {
-		t.Errorf("UID = %q; want UID = %q", vt.UID, "user1")
+	if vt.UID != uid {
+		t.Errorf("UID = %q; want UID = %q", vt.UID, uid)
 	}
-	if err = client.DeleteUser(context.Background(), "user1"); err != nil {
-		t.Error(err)
+	if premium, ok := vt.Claims["premium"].(bool); !ok || !premium {
+		t.Errorf("Claims['premium'] = %v; want Claims['premium'] = true", vt.Claims["premium"])
+	}
+	if pkg, ok := vt.Claims["package"].(string); !ok || pkg != "gold" {
+		t.Errorf("Claims['package'] = %v; want Claims['package'] = \"gold\"", vt.Claims["package"])
 	}
 }
 
-func TestVerifyIDTokenAndCheckRevoked(t *testing.T) {
+func TestRevokeRefreshTokens(t *testing.T) {
 	uid := "user_revoked"
 	ct, err := client.CustomToken(context.Background(), uid)
-
 	if err != nil {
 		t.Fatal(err)
 	}
 	idt, err := signInWithCustomToken(ct)
 	if err != nil {
 		t.Fatal(err)
 	}
-	ctx := context.Background()
-	vt, err := client.VerifyIDTokenAndCheckRevoked(ctx, idt)
+	defer deleteUser(uid)
+
+	vt, err := client.VerifyIDTokenAndCheckRevoked(context.Background(), idt)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if vt.UID != uid {
 		t.Errorf("UID = %q; want UID = %q", vt.UID, uid)
 	}
+
 	// The backend stores the validSince property in seconds since the epoch.
 	// The issuedAt property of the token is also in seconds. If a token was
 	// issued, and then in the same second tokens were revoked, the token will
 	// have the same timestamp as the tokensValidAfterMillis, and will therefore
 	// not be considered revoked. Hence we wait one second before revoking.
 	time.Sleep(time.Second)
-	if err = client.RevokeRefreshTokens(ctx, uid); err != nil {
+	if err = client.RevokeRefreshTokens(context.Background(), uid); err != nil {
 		t.Fatal(err)
 	}
 
-	vt, err = client.VerifyIDTokenAndCheckRevoked(ctx, idt)
+	vt, err = client.VerifyIDTokenAndCheckRevoked(context.Background(), idt)
 	we := "ID token has been revoked"
 	if vt != nil || err == nil || err.Error() != we {
 		t.Errorf("tok, err := VerifyIDTokenAndCheckRevoked(); got (%v, %s) ; want (%v, %v)",
 			vt, err, nil, we)
 	}
 
 	// Does not return error for revoked token.
-	if _, err = client.VerifyIDToken(ctx, idt); err != nil {
+	if _, err = client.VerifyIDToken(context.Background(), idt); err != nil {
 		t.Errorf("VerifyIDToken(); err = %s; want err = <nil>", err)
 	}
 
 	// Sign in after revocation.
 	if idt, err = signInWithCustomToken(ct); err != nil {
 		t.Fatal(err)
 	}
-
-	if _, err = client.VerifyIDTokenAndCheckRevoked(ctx, idt); err != nil {
+	if _, err = client.VerifyIDTokenAndCheckRevoked(context.Background(), idt); err != nil {
 		t.Errorf("VerifyIDTokenAndCheckRevoked(); err = %s; want err = <nil>", err)
 	}
-
-	err = client.DeleteUser(ctx, uid)
-	if err != nil {
-		t.Error(err)
-	}
-}
-
-func TestCustomTokenWithClaims(t *testing.T) {
-	ct, err := client.CustomTokenWithClaims(context.Background(), "user2", map[string]interface{}{
-		"premium": true,
-		"package": "gold",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	idt, err := signInWithCustomToken(ct)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	vt, err := client.VerifyIDToken(context.Background(), idt)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if vt.UID != "user2" {
-		t.Errorf("UID = %q; want UID = %q", vt.UID, "user2")
-	}
-	if premium, ok := vt.Claims["premium"].(bool); !ok || !premium {
-		t.Errorf("Claims['premium'] = %v; want Claims['premium'] = true", vt.Claims["premium"])
-	}
-	if pkg, ok := vt.Claims["package"].(string); !ok || pkg != "gold" {
-		t.Errorf("Claims['package'] = %v; want Claims['package'] = \"gold\"", vt.Claims["package"])
-	}
-	if err = client.DeleteUser(context.Background(), "user2"); err != nil {
-		t.Error(err)
-	}
 }
 
 func signInWithCustomToken(token string) (string, error) {
@@ -235,3 +225,10 @@ func postRequest(url string, req []byte) ([]byte, error) {
 	}
 	return ioutil.ReadAll(resp.Body)
 }
+
+// deleteUser makes a best effort attempt to delete the given user.
+//
+// Any errors encountered during the delete are ignored.
+func deleteUser(uid string) {
+	client.DeleteUser(context.Background(), uid)
+}