Add test case reproducing matrix-org/synapse#5677 for local users

internal/client/client.go

@@ -108,21 +108,6 @@ func (c *CSAPI) InviteRoom(t *testing.T, roomID string, userID string) {
 	c.MustDo(t, "POST", []string{"_matrix", "client", "r0", "rooms", roomID, "invite"}, body)
 }
 
-// SearchUserDirectory makes a request to search the user directory with a given query.
-// We don't include an explicit limit on the number of results returned, relying on
-// the spec's default of 10.
-func (c *CSAPI) SearchUserDirectory(t *testing.T, query string) *http.Response {
-	t.Helper()
-	return c.MustDoFunc(
-		t,
-		"POST",
-		[]string{"_matrix", "client", "r0", "user_directory", "search"},
-		WithJSONBody(t, map[string]interface{}{
-			"search_term": query,
-		}),
-	)
-}
-
 // SendEventSynced sends `e` into the room and waits for its event ID to come down /sync.
 // Returns the event ID of the sent event.
 func (c *CSAPI) SendEventSynced(t *testing.T, roomID string, e b.Event) string {

tests/csapi/user_directory_display_names_test.go

@@ -9,7 +9,21 @@ import (
 	"github.com/matrix-org/complement/internal/must"
 )
 
-func TestRoomSpecificUsernameHandling(t *testing.T) {
+const aliceId = "@alice:hs1"
+const alicePublicName = "Alice Cooper"
+const alicePrivateName = "Freddy"
+
+var justAliceByPublicName = []match.JSON{
+	match.JSONKeyArrayOfSize("results", 1),
+	match.JSONKeyEqual("results.0.display_name", alicePublicName),
+	match.JSONKeyEqual("results.0.user_id", aliceId),
+}
+
+var noResults = []match.JSON{
+	match.JSONKeyArrayOfSize("results", 0),
+}
+
+func setupUsers(t *testing.T) (*client.CSAPI, *client.CSAPI, *client.CSAPI) {
 	// Originally written to reproduce https://github.com/matrix-org/synapse/issues/5677
 	// In that bug report,
 	// - Bob knows about Alice, and
@@ -19,18 +33,17 @@ func TestRoomSpecificUsernameHandling(t *testing.T) {
 	// I've tweaked the names to be more traditional:
 	// - Eve knows about Alice,
 	// - Alice reveals a private name to another friend Bob
-	// - Eve shouldn't be able to see that private name.
+	// - Eve shouldn't be able to see that private name via the directory.
 	deployment := Deploy(t, b.BlueprintAlice)
 	defer deployment.Destroy(t)
 
-	alice := deployment.Client(t, "hs1", "@alice:hs1")
+	alice := deployment.Client(t, "hs1", aliceId)
 	bob := deployment.RegisterUser(t, "hs1", "bob", "bob-has-a-very-secret-pw")
 	eve := deployment.RegisterUser(t, "hs1", "eve", "eve-has-a-very-secret-pw")
 
 	// Alice sets her profile displayname. This ensures that her
 	// public name, private name and userid localpart are all
 	// distinguishable, even case-insensitively.
-	const alicePublicName = "Alice Cooper"
 	alice.MustDoFunc(
 		t,
 		"PUT",
@@ -40,9 +53,81 @@ func TestRoomSpecificUsernameHandling(t *testing.T) {
 		}),
 	)
 
-	// Alice creates a public room (so Eve can see that Alice exists)
+	// Alice creates a public room (so when Eve searches, she can see that Alice exists)
 	alice.CreateRoom(t, map[string]interface{}{"visibility": "public"})
 
+	return alice, bob, eve
+}
+
+func checkExpectations(t *testing.T, bob, eve *client.CSAPI) {
+	t.Run("Eve can find Alice by profile display name", func(t *testing.T) {
+		res := eve.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": alicePublicName,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{JSON: justAliceByPublicName})
+	})
+
+	t.Run("Eve can find Alice by mxid", func(t *testing.T) {
+		res := eve.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": aliceId,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{JSON: justAliceByPublicName})
+	})
+
+	t.Run("Eve cannot find Alice by room-specific name that Eve is not privy to", func(t *testing.T) {
+		res := eve.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": alicePrivateName,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{JSON: noResults})
+	})
+
+	t.Run("Bob can find Alice by profile display name", func(t *testing.T) {
+		res := bob.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": alicePublicName,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{
+			JSON: justAliceByPublicName,
+		})
+	})
+
+	t.Run("Bob can find Alice by mxid", func(t *testing.T) {
+		res := bob.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": aliceId,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{
+			JSON: justAliceByPublicName,
+		})
+	})
+}
+
+func TestRoomSpecificUsernameChange(t *testing.T) {
+	alice, bob, eve := setupUsers(t)
+
 	// Bob creates a new room and invites Alice.
 	privateRoom := bob.CreateRoom(t, map[string]interface{}{
 		"visibility": "private",
@@ -54,58 +139,43 @@ func TestRoomSpecificUsernameHandling(t *testing.T) {
 	alice.JoinRoom(t, privateRoom, nil)
 
 	// Alice reveals her private name to Bob
-	const alicePrivateName = "Freddy"
 	alice.MustDoFunc(
 		t,
 		"PUT",
-		[]string{"_matrix", "client", "r0", "rooms", privateRoom, "state", "m.room.member", "@alice:hs1"},
+		[]string{"_matrix", "client", "r0", "rooms", privateRoom, "state", "m.room.member", alice.UserID},
 		client.WithJSONBody(t, map[string]interface{}{
 			"displayname": alicePrivateName,
 			"membership":  "join",
 		}),
 	)
 
-	justAliceByPublicName := []match.JSON{
-		match.JSONKeyArrayOfSize("results", 1),
-		match.JSONKeyEqual("results.0.display_name", alicePublicName),
-		match.JSONKeyEqual("results.0.user_id", alice.UserID),
-	}
-
-	t.Run("Eve can find Alice by profile display name",
-		func(t *testing.T) {
-			res := eve.SearchUserDirectory(t, alicePublicName)
-			must.MatchResponse(t, res, match.HTTPResponse{JSON: justAliceByPublicName})
-		})
+	checkExpectations(t, bob, eve)
+}
 
-	t.Run("Eve can find Alice by mxid",
-		func(t *testing.T) {
-			res := eve.SearchUserDirectory(t, alice.UserID)
-			must.MatchResponse(t, res, match.HTTPResponse{JSON: justAliceByPublicName})
-		})
+func TestRoomSpecificUsernameAtJoin(t *testing.T) {
+	alice, bob, eve := setupUsers(t)
 
-	noResults := []match.JSON{
-		match.JSONKeyArrayOfSize("results", 0),
-	}
+	// Bob creates a new room and invites Alice.
+	privateRoom := bob.CreateRoom(t, map[string]interface{}{
+		"visibility": "private",
+		"invite":     []string{alice.UserID},
+	})
 
-	t.Run("Eve cannot find Alice by room-specific name that Eve is not privy to",
-		func(t *testing.T) {
-			res := eve.SearchUserDirectory(t, alicePrivateName)
-			must.MatchResponse(t, res, match.HTTPResponse{JSON: noResults})
-		})
+	// Alice waits until she sees the invite, then accepts.
+	// When she accepts, she does so with a specific displayname.
+	alice.SyncUntilInvitedTo(t, privateRoom)
+	alice.JoinRoom(t, privateRoom, nil)
 
-	t.Run("Bob can find Alice by profile display name",
-		func(t *testing.T) {
-			res := bob.SearchUserDirectory(t, alicePublicName)
-			must.MatchResponse(t, res, match.HTTPResponse{
-				JSON: justAliceByPublicName,
-			})
-		})
+	// Alice reveals her private name to Bob
+	alice.MustDoFunc(
+		t,
+		"PUT",
+		[]string{"_matrix", "client", "r0", "rooms", privateRoom, "state", "m.room.member", alice.UserID},
+		client.WithJSONBody(t, map[string]interface{}{
+			"displayname": alicePrivateName,
+			"membership":  "join",
+		}),
+	)
 
-	t.Run("Bob can find Alice by mxid",
-		func(t *testing.T) {
-			res := bob.SearchUserDirectory(t, alice.UserID)
-			must.MatchResponse(t, res, match.HTTPResponse{
-				JSON: justAliceByPublicName,
-			})
-		})
+	checkExpectations(t, bob, eve)
 }

tests/user_directory_federated_display_names_test.go

@@ -88,41 +88,72 @@ func TestRoomSpecificUsernameHandlingOverFederation(t *testing.T) {
 		match.JSONKeyEqual("results.0.user_id", remoteCharlie.UserID),
 	}
 
-	t.Run("Eve can find Charlie by profile display name",
-		func(t *testing.T) {
-			res := eve.SearchUserDirectory(t, charliePublicName)
-			must.MatchResponse(t, res, match.HTTPResponse{JSON: justCharlieByPublicNameOrMxid})
-		})
+	t.Run("Eve can find Charlie by profile display name", func(t *testing.T) {
+		res := eve.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": charliePublicName,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{JSON: justCharlieByPublicNameOrMxid})
+	})
 
-	t.Run("Eve can find Charlie by mxid",
-		func(t *testing.T) {
-			res := eve.SearchUserDirectory(t, remoteCharlie.UserID)
-			must.MatchResponse(t, res, match.HTTPResponse{JSON: justCharlieByPublicNameOrMxid})
-		})
+	t.Run("Eve can find Charlie by mxid", func(t *testing.T) {
+		res := eve.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": remoteCharlie.UserID,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{JSON: justCharlieByPublicNameOrMxid})
+	})
 
 	noResults := []match.JSON{
 		match.JSONKeyArrayOfSize("results", 0),
 	}
 
 	t.Run("Eve cannot find Charlie by room-specific name that Eve is not privy to",
 		func(t *testing.T) {
-			res := eve.SearchUserDirectory(t, charliePrivateName)
+			res := eve.MustDoFunc(
+				t,
+				"POST",
+				[]string{"_matrix", "client", "r0", "user_directory", "search"},
+				client.WithJSONBody(t, map[string]interface{}{
+					"search_term": charliePrivateName,
+				}),
+			)
 			must.MatchResponse(t, res, match.HTTPResponse{JSON: noResults})
 		})
 
-	t.Run("Bob can find Charlie by profile display name",
-		func(t *testing.T) {
-			res := bob.SearchUserDirectory(t, charliePublicName)
-			must.MatchResponse(t, res, match.HTTPResponse{
-				JSON: justCharlieByPublicNameOrMxid,
-			})
+	t.Run("Bob can find Charlie by profile display name", func(t *testing.T) {
+		res := bob.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": charliePublicName,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{
+			JSON: justCharlieByPublicNameOrMxid,
 		})
+	})
 
-	t.Run("Bob can find Charlie by mxid",
-		func(t *testing.T) {
-			res := bob.SearchUserDirectory(t, remoteCharlie.UserID)
-			must.MatchResponse(t, res, match.HTTPResponse{
-				JSON: justCharlieByPublicNameOrMxid,
-			})
+	t.Run("Bob can find Charlie by mxid", func(t *testing.T) {
+		res := bob.MustDoFunc(
+			t,
+			"POST",
+			[]string{"_matrix", "client", "r0", "user_directory", "search"},
+			client.WithJSONBody(t, map[string]interface{}{
+				"search_term": remoteCharlie.UserID,
+			}),
+		)
+		must.MatchResponse(t, res, match.HTTPResponse{
+			JSON: justCharlieByPublicNameOrMxid,
 		})
+	})
 }