package roomserver_test import ( "context" "reflect" "testing" "time" "github.com/matrix-org/dendrite/setup/base" "github.com/matrix-org/dendrite/userapi" userAPI "github.com/matrix-org/dendrite/userapi/api" "github.com/matrix-org/dendrite/federationapi" "github.com/matrix-org/dendrite/keyserver" "github.com/matrix-org/dendrite/setup/jetstream" "github.com/matrix-org/dendrite/syncapi" "github.com/matrix-org/gomatrixserverlib" "github.com/matrix-org/dendrite/roomserver" "github.com/matrix-org/dendrite/roomserver/api" "github.com/matrix-org/dendrite/roomserver/storage" "github.com/matrix-org/dendrite/test" "github.com/matrix-org/dendrite/test/testrig" ) func mustCreateDatabase(t *testing.T, dbType test.DBType) (*base.BaseDendrite, storage.Database, func()) { t.Helper() base, close := testrig.CreateBaseDendrite(t, dbType) db, err := storage.Open(base, &base.Cfg.RoomServer.Database, base.Caches) if err != nil { t.Fatalf("failed to create Database: %v", err) } return base, db, close } func TestUsers(t *testing.T) { test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) { base, close := testrig.CreateBaseDendrite(t, dbType) defer close() rsAPI := roomserver.NewInternalAPI(base) // SetFederationAPI starts the room event input consumer rsAPI.SetFederationAPI(nil, nil) t.Run("shared users", func(t *testing.T) { testSharedUsers(t, rsAPI) }) t.Run("kick users", func(t *testing.T) { usrAPI := userapi.NewInternalAPI(base, &base.Cfg.UserAPI, nil, nil, rsAPI, nil) rsAPI.SetUserAPI(usrAPI) testKickUsers(t, rsAPI, usrAPI) }) }) } func testSharedUsers(t *testing.T, rsAPI api.RoomserverInternalAPI) { alice := test.NewUser(t) bob := test.NewUser(t) room := test.NewRoom(t, alice, test.RoomPreset(test.PresetTrustedPrivateChat)) // Invite and join Bob room.CreateAndInsert(t, alice, gomatrixserverlib.MRoomMember, map[string]interface{}{ "membership": "invite", }, test.WithStateKey(bob.ID)) room.CreateAndInsert(t, bob, gomatrixserverlib.MRoomMember, map[string]interface{}{ "membership": "join", }, test.WithStateKey(bob.ID)) ctx := context.Background() // Create the room if err := api.SendEvents(ctx, rsAPI, api.KindNew, room.Events(), "test", "test", "test", nil, false); err != nil { t.Errorf("failed to send events: %v", err) } // Query the shared users for Alice, there should only be Bob. // This is used by the SyncAPI keychange consumer. res := &api.QuerySharedUsersResponse{} if err := rsAPI.QuerySharedUsers(ctx, &api.QuerySharedUsersRequest{UserID: alice.ID}, res); err != nil { t.Errorf("unable to query known users: %v", err) } if _, ok := res.UserIDsToCount[bob.ID]; !ok { t.Errorf("expected to find %s in shared users, but didn't: %+v", bob.ID, res.UserIDsToCount) } // Also verify that we get the expected result when specifying OtherUserIDs. // This is used by the SyncAPI when getting device list changes. if err := rsAPI.QuerySharedUsers(ctx, &api.QuerySharedUsersRequest{UserID: alice.ID, OtherUserIDs: []string{bob.ID}}, res); err != nil { t.Errorf("unable to query known users: %v", err) } if _, ok := res.UserIDsToCount[bob.ID]; !ok { t.Errorf("expected to find %s in shared users, but didn't: %+v", bob.ID, res.UserIDsToCount) } } func testKickUsers(t *testing.T, rsAPI api.RoomserverInternalAPI, usrAPI userAPI.UserInternalAPI) { // Create users and room; Bob is going to be the guest and kicked on revocation of guest access alice := test.NewUser(t, test.WithAccountType(userAPI.AccountTypeUser)) bob := test.NewUser(t, test.WithAccountType(userAPI.AccountTypeGuest)) room := test.NewRoom(t, alice, test.RoomPreset(test.PresetPublicChat), test.GuestsCanJoin(true)) // Join with the guest user room.CreateAndInsert(t, bob, gomatrixserverlib.MRoomMember, map[string]interface{}{ "membership": "join", }, test.WithStateKey(bob.ID)) ctx := context.Background() // Create the users in the userapi, so the RSAPI can query the account type later for _, u := range []*test.User{alice, bob} { localpart, serverName, _ := gomatrixserverlib.SplitID('@', u.ID) userRes := &userAPI.PerformAccountCreationResponse{} if err := usrAPI.PerformAccountCreation(ctx, &userAPI.PerformAccountCreationRequest{ AccountType: u.AccountType, Localpart: localpart, ServerName: serverName, Password: "someRandomPassword", }, userRes); err != nil { t.Errorf("failed to create account: %s", err) } } // Create the room in the database if err := api.SendEvents(ctx, rsAPI, api.KindNew, room.Events(), "test", "test", "test", nil, false); err != nil { t.Errorf("failed to send events: %v", err) } // Get the membership events BEFORE revoking guest access membershipRes := &api.QueryMembershipsForRoomResponse{} if err := rsAPI.QueryMembershipsForRoom(ctx, &api.QueryMembershipsForRoomRequest{LocalOnly: true, JoinedOnly: true, RoomID: room.ID}, membershipRes); err != nil { t.Errorf("failed to query membership for room: %s", err) } // revoke guest access revokeEvent := room.CreateAndInsert(t, alice, gomatrixserverlib.MRoomGuestAccess, map[string]string{"guest_access": "forbidden"}, test.WithStateKey("")) if err := api.SendEvents(ctx, rsAPI, api.KindNew, []*gomatrixserverlib.HeaderedEvent{revokeEvent}, "test", "test", "test", nil, false); err != nil { t.Errorf("failed to send events: %v", err) } // TODO: Even though we are sending the events sync, the "kickUsers" function is sending the events async, so we need // to loop and wait for the events to be processed by the roomserver. for i := 0; i <= 20; i++ { // Get the membership events AFTER revoking guest access membershipRes2 := &api.QueryMembershipsForRoomResponse{} if err := rsAPI.QueryMembershipsForRoom(ctx, &api.QueryMembershipsForRoomRequest{LocalOnly: true, JoinedOnly: true, RoomID: room.ID}, membershipRes2); err != nil { t.Errorf("failed to query membership for room: %s", err) } // The membership events should NOT match, as Bob (guest user) should now be kicked from the room if !reflect.DeepEqual(membershipRes, membershipRes2) { return } time.Sleep(time.Millisecond * 10) } t.Errorf("memberships didn't change in time") } func Test_QueryLeftUsers(t *testing.T) { alice := test.NewUser(t) bob := test.NewUser(t) room := test.NewRoom(t, alice, test.RoomPreset(test.PresetTrustedPrivateChat)) // Invite and join Bob room.CreateAndInsert(t, alice, gomatrixserverlib.MRoomMember, map[string]interface{}{ "membership": "invite", }, test.WithStateKey(bob.ID)) room.CreateAndInsert(t, bob, gomatrixserverlib.MRoomMember, map[string]interface{}{ "membership": "join", }, test.WithStateKey(bob.ID)) ctx := context.Background() test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) { base, _, close := mustCreateDatabase(t, dbType) defer close() rsAPI := roomserver.NewInternalAPI(base) // SetFederationAPI starts the room event input consumer rsAPI.SetFederationAPI(nil, nil) // Create the room if err := api.SendEvents(ctx, rsAPI, api.KindNew, room.Events(), "test", "test", "test", nil, false); err != nil { t.Fatalf("failed to send events: %v", err) } // Query the left users, there should only be "@idontexist:test", // as Alice and Bob are still joined. res := &api.QueryLeftUsersResponse{} leftUserID := "@idontexist:test" getLeftUsersList := []string{alice.ID, bob.ID, leftUserID} testCase := func(rsAPI api.RoomserverInternalAPI) { if err := rsAPI.QueryLeftUsers(ctx, &api.QueryLeftUsersRequest{StaleDeviceListUsers: getLeftUsersList}, res); err != nil { t.Fatalf("unable to query left users: %v", err) } wantCount := 1 if count := len(res.LeftUsers); count > wantCount { t.Fatalf("unexpected left users count: want %d, got %d", wantCount, count) } if res.LeftUsers[0] != leftUserID { t.Fatalf("unexpected left users : want %s, got %s", leftUserID, res.LeftUsers[0]) } } testCase(rsAPI) }) } func TestPurgeRoom(t *testing.T) { alice := test.NewUser(t) bob := test.NewUser(t) room := test.NewRoom(t, alice, test.RoomPreset(test.PresetTrustedPrivateChat)) // Invite Bob inviteEvent := room.CreateAndInsert(t, alice, gomatrixserverlib.MRoomMember, map[string]interface{}{ "membership": "invite", }, test.WithStateKey(bob.ID)) ctx := context.Background() test.WithAllDatabases(t, func(t *testing.T, dbType test.DBType) { base, db, close := mustCreateDatabase(t, dbType) defer close() jsCtx, _ := base.NATS.Prepare(base.ProcessContext, &base.Cfg.Global.JetStream) defer jetstream.DeleteAllStreams(jsCtx, &base.Cfg.Global.JetStream) fedClient := base.CreateFederationClient() rsAPI := roomserver.NewInternalAPI(base) keyAPI := keyserver.NewInternalAPI(base, &base.Cfg.KeyServer, fedClient, rsAPI) userAPI := userapi.NewInternalAPI(base, &base.Cfg.UserAPI, nil, keyAPI, rsAPI, nil) // this starts the JetStream consumers syncapi.AddPublicRoutes(base, userAPI, rsAPI, keyAPI) federationapi.NewInternalAPI(base, fedClient, rsAPI, base.Caches, nil, true) rsAPI.SetFederationAPI(nil, nil) // Create the room if err := api.SendEvents(ctx, rsAPI, api.KindNew, room.Events(), "test", "test", "test", nil, false); err != nil { t.Fatalf("failed to send events: %v", err) } // some dummy entries to validate after purging publishResp := &api.PerformPublishResponse{} if err := rsAPI.PerformPublish(ctx, &api.PerformPublishRequest{RoomID: room.ID, Visibility: "public"}, publishResp); err != nil { t.Fatal(err) } if publishResp.Error != nil { t.Fatal(publishResp.Error) } isPublished, err := db.GetPublishedRoom(ctx, room.ID) if err != nil { t.Fatal(err) } if !isPublished { t.Fatalf("room should be published before purging") } aliasResp := &api.SetRoomAliasResponse{} if err = rsAPI.SetRoomAlias(ctx, &api.SetRoomAliasRequest{RoomID: room.ID, Alias: "myalias", UserID: alice.ID}, aliasResp); err != nil { t.Fatal(err) } // check the alias is actually there aliasesResp := &api.GetAliasesForRoomIDResponse{} if err = rsAPI.GetAliasesForRoomID(ctx, &api.GetAliasesForRoomIDRequest{RoomID: room.ID}, aliasesResp); err != nil { t.Fatal(err) } wantAliases := 1 if gotAliases := len(aliasesResp.Aliases); gotAliases != wantAliases { t.Fatalf("expected %d aliases, got %d", wantAliases, gotAliases) } // validate the room exists before purging roomInfo, err := db.RoomInfo(ctx, room.ID) if err != nil { t.Fatal(err) } if roomInfo == nil { t.Fatalf("room does not exist") } // remember the roomInfo before purging existingRoomInfo := roomInfo // validate there is an invite for bob nids, err := db.EventStateKeyNIDs(ctx, []string{bob.ID}) if err != nil { t.Fatal(err) } bobNID, ok := nids[bob.ID] if !ok { t.Fatalf("%s does not exist", bob.ID) } _, inviteEventIDs, _, err := db.GetInvitesForUser(ctx, roomInfo.RoomNID, bobNID) if err != nil { t.Fatal(err) } wantInviteCount := 1 if inviteCount := len(inviteEventIDs); inviteCount != wantInviteCount { t.Fatalf("expected there to be only %d invite events, got %d", wantInviteCount, inviteCount) } if inviteEventIDs[0] != inviteEvent.EventID() { t.Fatalf("expected invite event ID %s, got %s", inviteEvent.EventID(), inviteEventIDs[0]) } // purge the room from the database purgeResp := &api.PerformAdminPurgeRoomResponse{} if err = rsAPI.PerformAdminPurgeRoom(ctx, &api.PerformAdminPurgeRoomRequest{RoomID: room.ID}, purgeResp); err != nil { t.Fatal(err) } // wait for all consumers to process the purge event var sum = 1 timeout := time.Second * 5 deadline, cancel := context.WithTimeout(context.Background(), timeout) defer cancel() for sum > 0 { if deadline.Err() != nil { t.Fatalf("test timed out after %s", timeout) } sum = 0 consumerCh := jsCtx.Consumers(base.Cfg.Global.JetStream.Prefixed(jetstream.OutputRoomEvent)) for x := range consumerCh { sum += x.NumAckPending } time.Sleep(time.Millisecond) } roomInfo, err = db.RoomInfo(ctx, room.ID) if err != nil { t.Fatal(err) } if roomInfo != nil { t.Fatalf("room should not exist after purging: %+v", roomInfo) } // validation below // There should be no invite left _, inviteEventIDs, _, err = db.GetInvitesForUser(ctx, existingRoomInfo.RoomNID, bobNID) if err != nil { t.Fatal(err) } if inviteCount := len(inviteEventIDs); inviteCount > 0 { t.Fatalf("expected there to be only %d invite events, got %d", wantInviteCount, inviteCount) } // aliases should be deleted aliases, err := db.GetAliasesForRoomID(ctx, room.ID) if err != nil { t.Fatal(err) } if aliasCount := len(aliases); aliasCount > 0 { t.Fatalf("expected there to be only %d invite events, got %d", 0, aliasCount) } // published room should be deleted isPublished, err = db.GetPublishedRoom(ctx, room.ID) if err != nil { t.Fatal(err) } if isPublished { t.Fatalf("room should not be published after purging") } }) }