Add deployment.GetFullyQualifiedHomeserverName(t, hsName) to support custom Deployment (matrix-org#780)

*Split off from matrix-org#778 per
[discussion](matrix-org#778 (comment)

Spawning from a real use-case with a custom `Deployment`/`Deployer` (Element-internal).

Introduce `complement.Deployment.GetFullyQualifiedHomeserverName(hsName)` to allow the
per-deployment short homeserver aliases like `hs1` to be mapped to something else that's
resolvable in your custom deployments context. Example: `hs1` -> `hs1.shard1:8481`.

This is useful for situations like the following where you have to specify the via
servers in a federated join request during a test:

```go
alice.MustJoinRoom(t, bobRoomID, []string{
	deployment.GetFullyQualifiedHomeserverName(t, "hs2"),
})
```


### But why does this have to be part of the `complement.Deployment` interface instead of your own custom deployment?

 - Tests only have access to the generic `complement.Deployment` interface
 - We can't derive fully-qualified homeserver names from the existing
   `complement.Deployment` interface
 - While we could cheekily cast the generic `complement.Deployment` back to
   `CustomDeployment` in our own tests (and have the helper in the `CustomDeployment`
   instead), if we start using something exotic in our out-of-repo Complement tests, the
   suite of existing Complement tests in this repo will not be compatible.

(also see below)

### Motivating custom `Deployment` use case

[`complement.Deployment`](https://github.com/matrix-org/complement/blob/d2e04c995666fbeb0948e6a4ed52d3fbb45fbdf7/test_package.go#L21-L69)
is an interface that can be backed by anything. For reference, custom deployments were
introduced in matrix-org#750. The [default
`Deployment` naming scheme in Complement is `hs1`, `hs2`,
etc](https://github.com/matrix-org/complement/blob/6b63eff50804beb334ca215650f5027ddf02ae9a/test_package.go#L198).
It's really nice and convenient to be able to simply refer to homeservers as `hs1`, etc
within a deployment. And using consistent names like this makes tests compatible with
each other regardless of which `Deployment` is being used.

The built-in `Deployment` in Complement has each homeserver in a Docker container which
already has network aliases like `hs1`, `hs2`, etc so no translation is needed from
friendly name to resolvable address. When one homeserver needs to federate with the
other, it can simply make a request to `https://hs1:8448/...` per [spec on resolving
server names](https://spec.matrix.org/v1.13/server-server-api/#resolving-server-names).

Right-now, we hard-code `hs1` across the tests when we specify ["via" servers in join
requests](https://spec.matrix.org/v1.13/client-server-api/#post_matrixclientv3joinroomidoralias)
but that only works if you follow the strict single-deployment naming scheme. 

https://github.com/matrix-org/complement/blob/6b63eff50804beb334ca215650f5027ddf02ae9a/tests/federation_rooms_invite_test.go#L112

In the current setup of our custom `Deployment`, each `Deployment` is a "shard"
application that can deploy multiple homeserver "tenants". We specifically want to test
that homeservers between multiple shards can federate with each other as a sanity check
(make sure our shards can deploy homeserver tenants correctly). If we keep using the
consistent `hs1`, `hs2` naming scheme for each `Deployment` we're going to have
conflicts. This is where `deployment.GetFullyQualifiedHomeserverName(t, hsName)` comes
in handy. We can call `deployment1.GetFullyQualifiedHomeserverName(t, "hs1")` ->
`hs1.shard1` and also `deployment2.GetFullyQualifiedHomeserverName(t, "hs1")` ->
`hs1.shard2` to get their unique resolvable addresses in the network.

Additionally, the helper removes the constraint of needing the network to strictly
resolve `hs1`, `hs2` hostnames to their respective homeservers. Whenever you need to
refer to another homeserver, use `deployment.GetFullyQualifiedHomeserverName(hsName)` to
take care of the nuance of environment that the given `Deployment` creates.

Example of a cross-deployment test:

```go
func TestMain(m *testing.M) {
	complement.TestMain(m, "custom_tests",
		complement.WithDeployment(internal.MakeCustomDeployment()),
	)
}

func TestCrossShardFederation(t *testing.T) {
	// Create two shards with their own homeserver tenants
	shardDeployment1 := complement.Deploy(t, 1)
	defer shardDeployment1.Destroy(t)
	shardDeployment2 := complement.Deploy(t, 1)
	defer shardDeployment2.Destroy(t)

	alice := shardDeployment1.Register(t, "hs1", helpers.RegistrationOpts{})
	bob := shardDeployment2.Register(t, "hs1", helpers.RegistrationOpts{})

	aliceRoomID := alice.MustCreateRoom(t, map[string]any{
		"preset": "public_chat",
	})
	bobRoomID := bob.MustCreateRoom(t, map[string]any{
		"preset": "public_chat",
	})

	t.Run("parallel", func(t *testing.T) {
		t.Run("shard1 -> shard2", func(t *testing.T) {
			// Since these tests use the same config, they can be run in parallel
			t.Parallel()

			alice.MustJoinRoom(t, bobRoomID, []string{
				shardDeployment2.GetFullyQualifiedHomeserverName(t, "hs1"),
			})

			bob.MustSyncUntil(t, client.SyncReq{}, client.SyncJoinedTo(alice.UserID, bobRoomID))
		})

		t.Run("shard2 -> shard1", func(t *testing.T) {
			// Since these tests use the same config, they can be run in parallel
			t.Parallel()

			bob.MustJoinRoom(t, aliceRoomID, []string{
				shardDeployment1.GetFullyQualifiedHomeserverName(t, "hs1"),
			})

			alice.MustSyncUntil(t, client.SyncReq{}, client.SyncJoinedTo(bob.UserID, aliceRoomID))
		})
	})
}
```

Per the discussion in
matrix-org#780 (comment),
multiple-deployments per test doesn't work with Complement's `Deployment` implementation
yet and the `Deployment` is meant to encapsulate an _entire_ deployment, all servers and
network links between them. This was the motivating use case but use at your own
discretion until further guidance is given.

Author: MadLittleMods

client/client.go

@@ -18,6 +18,7 @@ import (
 	"time"
 
 	"github.com/matrix-org/gomatrixserverlib"
+	"github.com/matrix-org/gomatrixserverlib/spec"
 	"github.com/tidwall/gjson"
 	"golang.org/x/crypto/curve25519"
 
@@ -139,7 +140,11 @@ func (c *CSAPI) CreateRoom(t ct.TestLike, body map[string]interface{}) *http.Res
 }
 
 // MustJoinRoom joins the room ID or alias given, else fails the test. Returns the room ID.
-func (c *CSAPI) MustJoinRoom(t ct.TestLike, roomIDOrAlias string, serverNames []string) string {
+//
+// Args:
+//   - `serverNames`: The list of servers to attempt to join the room through.
+//     These should be a resolvable addresses within the deployment network.
+func (c *CSAPI) MustJoinRoom(t ct.TestLike, roomIDOrAlias string, serverNames []spec.ServerName) string {
 	t.Helper()
 	res := c.JoinRoom(t, roomIDOrAlias, serverNames)
 	mustRespond2xx(t, res)
@@ -153,12 +158,19 @@ func (c *CSAPI) MustJoinRoom(t ct.TestLike, roomIDOrAlias string, serverNames []
 }
 
 // JoinRoom joins the room ID or alias given. Returns the raw http response
-func (c *CSAPI) JoinRoom(t ct.TestLike, roomIDOrAlias string, serverNames []string) *http.Response {
+//
+// Args:
+//   - `serverNames`: The list of servers to attempt to join the room through.
+//     These should be a resolvable addresses within the deployment network.
+func (c *CSAPI) JoinRoom(t ct.TestLike, roomIDOrAlias string, serverNames []spec.ServerName) *http.Response {
 	t.Helper()
 	// construct URL query parameters
-	query := make(url.Values, len(serverNames))
-	for _, serverName := range serverNames {
-		query.Add("server_name", serverName)
+	serverNameStrings := make([]string, len(serverNames))
+	for i, serverName := range serverNames {
+		serverNameStrings[i] = string(serverName)
+	}
+	query := url.Values{
+		"server_name": serverNameStrings,
 	}
 	// join the room
 	return c.Do(

federation/handle.go

@@ -117,7 +117,7 @@ func MakeRespMakeKnock(s *Server, room *ServerRoom, userID string) (resp fclient
 // the current server is returned to the joining server.
 func SendJoinRequestsHandler(s *Server, w http.ResponseWriter, req *http.Request, expectPartialState bool, omitServersInRoom bool) {
 	fedReq, errResp := fclient.VerifyHTTPRequest(
-		req, time.Now(), spec.ServerName(s.serverName), nil, s.keyRing,
+		req, time.Now(), s.serverName, nil, s.keyRing,
 	)
 	if fedReq == nil {
 		w.WriteHeader(errResp.Code)
@@ -208,7 +208,7 @@ func HandleInviteRequests(inviteCallback func(gomatrixserverlib.PDU)) func(*Serv
 		// https://matrix.org/docs/spec/server_server/r0.1.4#put-matrix-federation-v2-invite-roomid-eventid
 		s.mux.Handle("/_matrix/federation/v2/invite/{roomID}/{eventID}", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 			fedReq, errResp := fclient.VerifyHTTPRequest(
-				req, time.Now(), spec.ServerName(s.serverName), nil, s.keyRing,
+				req, time.Now(), s.serverName, nil, s.keyRing,
 			)
 			if fedReq == nil {
 				w.WriteHeader(errResp.Code)
@@ -236,7 +236,7 @@ func HandleInviteRequests(inviteCallback func(gomatrixserverlib.PDU)) func(*Serv
 			}
 
 			// Sign the event before we send it back
-			signedEvent := inviteRequest.Event().Sign(s.serverName, s.KeyID, s.Priv)
+			signedEvent := inviteRequest.Event().Sign(string(s.serverName), s.KeyID, s.Priv)
 
 			// Send the response
 			res := map[string]interface{}{
@@ -263,7 +263,7 @@ func HandleDirectoryLookups() func(*Server) {
 				b, err := json.Marshal(fclient.RespDirectory{
 					RoomID: roomID,
 					Servers: []spec.ServerName{
-						spec.ServerName(s.serverName),
+						s.serverName,
 					},
 				})
 				if err != nil {
@@ -432,7 +432,7 @@ func HandleMediaRequests(mediaIds map[string]func(w http.ResponseWriter)) func(*
 			origin := vars["origin"]
 			mediaId := vars["mediaId"]
 
-			if origin != srv.serverName {
+			if origin != string(srv.serverName) {
 				w.WriteHeader(400)
 				w.Write([]byte("complement: Invalid Origin; Expected " + srv.serverName))
 				return
@@ -471,7 +471,7 @@ func HandleTransactionRequests(pduCallback func(gomatrixserverlib.PDU), eduCallb
 
 			// Check federation signature
 			fedReq, errResp := fclient.VerifyHTTPRequest(
-				req, time.Now(), spec.ServerName(srv.serverName), nil, srv.keyRing,
+				req, time.Now(), srv.serverName, nil, srv.keyRing,
 			)
 			if fedReq == nil {
 				log.Printf(

federation/server.go

@@ -48,9 +48,10 @@ type Server struct {
 	// Default: true
 	UnexpectedRequestsAreErrors bool
 
-	Priv       ed25519.PrivateKey
-	KeyID      gomatrixserverlib.KeyID
-	serverName string
+	Priv  ed25519.PrivateKey
+	KeyID gomatrixserverlib.KeyID
+	// The homeserver name. This should be a resolvable address in the deployment network
+	serverName spec.ServerName
 	listening  bool
 
 	certPath string
@@ -80,7 +81,7 @@ func NewServer(t ct.TestLike, deployment FederationDeployment, opts ...func(*Ser
 		mux:   mux.NewRouter(),
 		// The server name will be updated when the caller calls Listen() to include the port number
 		// of the HTTP server e.g "host.docker.internal:56353"
-		serverName:                  deployment.GetConfig().HostnameRunningComplement,
+		serverName:                  spec.ServerName(deployment.GetConfig().HostnameRunningComplement),
 		rooms:                       make(map[string]*ServerRoom),
 		aliases:                     make(map[string]string),
 		UnexpectedRequestsAreErrors: true,
@@ -142,7 +143,7 @@ func NewServer(t ct.TestLike, deployment FederationDeployment, opts ...func(*Ser
 // It is not supported to call ServerName() before Listen() because Listen() modifies the server name.
 // Listen() will select a random OS-provided high-numbered port to listen on, which then needs to be
 // retrofitted into the server name so containers know how to route to it.
-func (s *Server) ServerName() string {
+func (s *Server) ServerName() spec.ServerName {
 	if !s.listening {
 		ct.Fatalf(s.t, "ServerName() called before Listen() - this is not supported because Listen() chooses a high-numbered port and thus changes the server name. Ensure you Listen() first!")
 	}
@@ -205,28 +206,31 @@ func (s *Server) FederationClient(deployment FederationDeployment) fclient.Feder
 		ct.Fatalf(s.t, "FederationClient() called before Listen() - this is not supported because Listen() chooses a high-numbered port and thus changes the server name and thus changes the way federation requests are signed. Ensure you Listen() first!")
 	}
 	identity := fclient.SigningIdentity{
-		ServerName: spec.ServerName(s.ServerName()),
+		ServerName: s.ServerName(),
 		KeyID:      s.KeyID,
 		PrivateKey: s.Priv,
 	}
-	f := fclient.NewFederationClient(
+	fedClient := fclient.NewFederationClient(
 		[]*fclient.SigningIdentity{&identity},
 		fclient.WithTransport(deployment.RoundTripper()),
 	)
-	return f
+	return fedClient
 }
 
 // MustSendTransaction sends the given PDUs/EDUs to the target destination, returning an error if the /send fails or if the response contains an error
 // for any sent PDUs. Times out after 10 seconds.
-func (s *Server) MustSendTransaction(t ct.TestLike, deployment FederationDeployment, destination string, pdus []json.RawMessage, edus []gomatrixserverlib.EDU) {
+//
+// Args:
+//   - `destination`: This should be a resolvable addresses within the deployment network.
+func (s *Server) MustSendTransaction(t ct.TestLike, deployment FederationDeployment, destination spec.ServerName, pdus []json.RawMessage, edus []gomatrixserverlib.EDU) {
 	t.Helper()
-	cli := s.FederationClient(deployment)
+	fedClient := s.FederationClient(deployment)
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 	defer cancel()
-	resp, err := cli.SendTransaction(ctx, gomatrixserverlib.Transaction{
+	resp, err := fedClient.SendTransaction(ctx, gomatrixserverlib.Transaction{
 		TransactionID: gomatrixserverlib.TransactionID(fmt.Sprintf("complement-%d", time.Now().Nanosecond())),
 		Origin:        spec.ServerName(s.ServerName()),
-		Destination:   spec.ServerName(destination),
+		Destination:   destination,
 		PDUs:          pdus,
 		EDUs:          edus,
 	})
@@ -319,6 +323,9 @@ func (s *Server) MustCreateEvent(t ct.TestLike, room *ServerRoom, ev Event) goma
 
 // MustJoinRoom will make the server send a make_join and a send_join to join a room
 // It returns the resultant room.
+//
+// Args:
+//   - `remoteServer`: This should be a resolvable addresses within the deployment network.
 func (s *Server) MustJoinRoom(t ct.TestLike, deployment FederationDeployment, remoteServer spec.ServerName, roomID string, userID string, opts ...JoinRoomOpt) *ServerRoom {
 	t.Helper()
 	var jr joinRoom
@@ -401,6 +408,9 @@ func (s *Server) MustJoinRoom(t ct.TestLike, deployment FederationDeployment, re
 }
 
 // Leaves a room. If this is rejecting an invite then a make_leave request is made first, before send_leave.
+//
+// Args:
+//   - `remoteServer`: This should be a resolvable addresses within the deployment network.
 func (s *Server) MustLeaveRoom(t ct.TestLike, deployment FederationDeployment, remoteServer spec.ServerName, roomID string, userID string) {
 	t.Helper()
 	origin := spec.ServerName(s.serverName)
@@ -449,7 +459,7 @@ func (s *Server) ValidFederationRequest(t ct.TestLike, handler func(fr *fclient.
 	return func(w http.ResponseWriter, req *http.Request) {
 		// Check federation signature
 		fedReq, errResp := fclient.VerifyHTTPRequest(
-			req, time.Now(), spec.ServerName(s.serverName), nil, s.keyRing,
+			req, time.Now(), s.serverName, nil, s.keyRing,
 		)
 		if fedReq == nil {
 			ct.Errorf(t,
@@ -495,7 +505,7 @@ func (s *Server) Listen() (cancel func()) {
 		ct.Fatalf(s.t, "ListenFederationServer: net.Listen failed: %s", err)
 	}
 	port := ln.Addr().(*net.TCPAddr).Port
-	s.serverName += fmt.Sprintf(":%d", port)
+	s.serverName = spec.ServerName(fmt.Sprintf("%s:%d", s.serverName, port))
 	s.listening = true
 
 	go func() {
@@ -647,7 +657,7 @@ func (f *basicKeyFetcher) FetchKeys(
 ) {
 	result := make(map[gomatrixserverlib.PublicKeyLookupRequest]gomatrixserverlib.PublicKeyLookupResult, len(requests))
 	for req := range requests {
-		if string(req.ServerName) == f.srv.serverName && req.KeyID == f.srv.KeyID {
+		if req.ServerName == f.srv.serverName && req.KeyID == f.srv.KeyID {
 			publicKey := f.srv.Priv.Public().(ed25519.PublicKey)
 			result[req] = gomatrixserverlib.PublicKeyLookupResult{
 				ValidUntilTS: spec.AsTimestamp(time.Now().Add(24 * time.Hour)),

federation/server_room.go

@@ -260,7 +260,7 @@ func (r *ServerRoom) MustHaveMembershipForUser(t ct.TestLike, userID, wantMember
 }
 
 // ServersInRoom gets all servers currently joined to the room
-func (r *ServerRoom) ServersInRoom() (servers []string) {
+func (r *ServerRoom) ServersInRoom() (servers []spec.ServerName) {
 	serverSet := make(map[string]struct{})
 
 	r.StateMutex.RLock()
@@ -282,7 +282,7 @@ func (r *ServerRoom) ServersInRoom() (servers []string) {
 	r.StateMutex.RUnlock()
 
 	for server := range serverSet {
-		servers = append(servers, server)
+		servers = append(servers, spec.ServerName(server))
 	}
 
 	return
@@ -498,21 +498,27 @@ func (i *ServerRoomImplDefault) GenerateSendJoinResponse(room *ServerRoom, s *Se
 	authEvents := room.AuthChainForEvents(stateEvents)
 
 	// get servers in room *before* the join event
-	serversInRoom := []string{s.serverName}
+	serversInRoom := []spec.ServerName{s.serverName}
 	if !omitServersInRoom {
 		serversInRoom = room.ServersInRoom()
 	}
 
+	serversInRoomStrings := make([]string, len(serversInRoom))
+	for i, serverName := range serversInRoom {
+		serversInRoomStrings[i] = string(serverName)
+	}
+
 	// insert the join event into the room state
 	room.AddEvent(joinEvent)
 	log.Printf("Received send-join of event %s", joinEvent.EventID())
 
 	// return state and auth chain
 	return fclient.RespSendJoin{
-		Origin:         spec.ServerName(s.serverName),
+		Origin:         s.serverName,
 		AuthEvents:     gomatrixserverlib.NewEventJSONsFromEvents(authEvents),
 		StateEvents:    gomatrixserverlib.NewEventJSONsFromEvents(stateEvents),
 		MembersOmitted: expectPartialState,
-		ServersInRoom:  serversInRoom,
+		// TODO: It feels like `ServersInRoom` should be `[]spec.ServerName` instead of `[]string`
+		ServersInRoom: serversInRoomStrings,
 	}
 }

federation/server_test.go

@@ -55,7 +55,7 @@ func TestComplementServerIsSigned(t *testing.T) {
 		transport := &http.Transport{TLSClientConfig: tc.config}
 		client := &http.Client{Transport: transport}
 
-		resp, err := client.Get("https://" + srv.ServerName())
+		resp, err := client.Get("https://" + string(srv.ServerName()))
 		if err != nil {
 			if tc.wantSuccess {
 				t.Fatalf("Failed to GET: %s", err)

internal/docker/deployment.go

@@ -12,6 +12,7 @@ import (
 	"github.com/matrix-org/complement/ct"
 	"github.com/matrix-org/complement/helpers"
 	"github.com/matrix-org/gomatrixserverlib"
+	"github.com/matrix-org/gomatrixserverlib/spec"
 )
 
 // Deployment is the complete instantiation of a Blueprint, with running containers
@@ -57,6 +58,16 @@ func (hsDep *HomeserverDeployment) SetEndpoints(baseURL string, fedBaseURL strin
 	}
 }
 
+func (d *Deployment) GetFullyQualifiedHomeserverName(t ct.TestLike, hsName string) spec.ServerName {
+	_, ok := d.HS[hsName]
+	if !ok {
+		ct.Fatalf(t, "Deployment.GetFullyQualifiedHomeserverName - HS name '%s' not found", hsName)
+	}
+	// We have network aliases for each Docker container that will resolve the `hsName` to
+	// the container.
+	return spec.ServerName(hsName)
+}
+
 // DestroyAtCleanup destroys the entire deployment. It should be called at cleanup time for dirty
 // deployments only. Handles configuration options for things which should run at container destroy
 // time, like post-run scripts and printing logs.

test_main.go

@@ -39,6 +39,12 @@ func WithCleanup(fn func(config *config.Complement)) opt {
 }
 
 // WithDeployment adds a custom mechanism to deploy homeservers.
+//
+// For test consistency and compatibility, deployers should be creating servers that can
+// be referred to as `hs1`, `hs2`, etc as the `hsName` in the `Deployment` interface.
+// The actual resolvable address of the homeserver in the network can be something
+// different and just needs to be mapped by
+// your implementation of `deployment.GetFullyQualifiedHomeserverName(hsName)`.
 func WithDeployment(fn func(t ct.TestLike, numServers int, config *config.Complement) Deployment) opt {
 	return func(co *complementOpts) {
 		co.customDeployment = fn
@@ -93,6 +99,9 @@ func OldDeploy(t ct.TestLike, blueprint b.Blueprint) Deployment {
 // Deploy will deploy the given number of servers or terminate the test.
 // This function is the main setup function for all tests as it provides a deployment with
 // which tests can interact with.
+//
+// For test consistency and compatibility, deployers should be creating servers that can
+// be referred to as `hs1`, `hs2`, etc as the `hsName` in the `Deployment` interface.
 func Deploy(t ct.TestLike, numServers int) Deployment {
 	t.Helper()
 	if testPackage == nil {

test_package.go

@@ -15,11 +15,19 @@ import (
 	"github.com/matrix-org/complement/ct"
 	"github.com/matrix-org/complement/helpers"
 	"github.com/matrix-org/complement/internal/docker"
+	"github.com/matrix-org/gomatrixserverlib/spec"
 	"github.com/sirupsen/logrus"
 )
 
 // Deployment provides a way for tests to interact with a set of homeservers.
 type Deployment interface {
+	// Returns the resolvable server name (host) of a homeserver given its short alias
+	// (e.g., "hs1", "hs2").
+	//
+	// In the case of the standard Docker deployment, this will be the same `hs1`, `hs2`
+	// but may be different for other custom deployments (ex.
+	// `shardDeployment1.GetFullyQualifiedHomeserverName(t, "hs1")` -> `hs1.shard1:8081`).
+	GetFullyQualifiedHomeserverName(t ct.TestLike, hsName string) spec.ServerName
 	// UnauthenticatedClient returns a blank CSAPI client.
 	UnauthenticatedClient(t ct.TestLike, serverName string) *client.CSAPI
 	// Register a new user on the given server.

tests/csapi/admin_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/matrix-org/complement/helpers"
 	"github.com/matrix-org/complement/match"
 	"github.com/matrix-org/complement/must"
+	"github.com/matrix-org/gomatrixserverlib/spec"
 )
 
 // Check if this homeserver supports Synapse-style admin registration.
@@ -69,7 +70,7 @@ func TestServerNotices(t *testing.T) {
 		})
 	})
 	t.Run("Alice can join the alert room", func(t *testing.T) {
-		alice.MustJoinRoom(t, roomID, []string{})
+		alice.MustJoinRoom(t, roomID, []spec.ServerName{})
 		alice.MustSyncUntil(t, client.SyncReq{}, client.SyncTimelineHasEventID(roomID, eventID))
 	})
 	t.Run("Alice can leave the alert room, after joining it", func(t *testing.T) {

tests/csapi/apidoc_presence_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/matrix-org/complement/helpers"
 	"github.com/matrix-org/complement/match"
 	"github.com/matrix-org/complement/must"
+	"github.com/matrix-org/gomatrixserverlib/spec"
 )
 
 func TestPresence(t *testing.T) {
@@ -27,7 +28,9 @@ func TestPresence(t *testing.T) {
 
 	// to share presence alice and bob must be in a shared room
 	roomID := alice.MustCreateRoom(t, map[string]interface{}{"preset": "public_chat"})
-	bob.MustJoinRoom(t, roomID, []string{"hs1"})
+	bob.MustJoinRoom(t, roomID, []spec.ServerName{
+		deployment.GetFullyQualifiedHomeserverName(t, "hs1"),
+	})
 
 	// sytest: GET /presence/:user_id/status fetches initial status
 	t.Run("GET /presence/:user_id/status fetches initial status", func(t *testing.T) {