Mock a response object

src/domain/session/room/timeline/tiles/RoomMemberTile.js

@@ -36,7 +36,7 @@ export class RoomMemberTile extends SimpleTile {
                 if (!content.displayname) {
                     return `${stateKey} removed their name (${prevContent.displayname})`;
                 }
-                return `${prevContent.displayname ?? stateKey} changed their name to ${content.displayname}`; 
+                return `${prevContent.displayname ? prevContent.displayname : stateKey} changed their name to ${content.displayname}`; 
             }
         } else if (membership === "join") {
             return `${targetName} joined the room`;

src/matrix/SessionContainer.js

@@ -51,7 +51,7 @@ function normalizeHomeserver(homeServer) {
 }
 
 export class SessionContainer {
-    constructor({platform, olmPromise, workerPromise}) {
+    constructor({platform, olmPromise, workerPromise, guestAccount = false}) {
         this._platform = platform;
         this._sessionStartedByReconnector = false;
         this._status = new ObservableValue(LoadStatus.NotLoading);
@@ -65,6 +65,7 @@ export class SessionContainer {
         this._requestScheduler = null;
         this._olmPromise = olmPromise;
         this._workerPromise = workerPromise;
+        this._guestAccount = guestAccount;
     }
 
     createNewSessionId() {
@@ -97,19 +98,29 @@ export class SessionContainer {
         });
     }
 
-    async startWithLogin(homeServer, username, password) {
+    async startWithLogin(homeServer, username, password, guestAccount = false) {
         if (this._status.get() !== LoadStatus.NotLoading) {
             return;
         }
         await this._platform.logger.run("login", async log => {
             this._status.set(LoadStatus.Login);
+            this._guestAccount = guestAccount;
             homeServer = normalizeHomeserver(homeServer);
             const clock = this._platform.clock;
             let sessionInfo;
             try {
                 const request = this._platform.request;
-                const hsApi = new HomeServerApi({homeServer, request});
+                const hsApi = new HomeServerApi({
-                const loginData = await hsApi.passwordLogin(username, password, "Hydrogen", {log}).response();
+                    homeServer,
+                    request,
+                    guestAccount: this._guestAccount
+                });
+                let loginData;
+                if (guestAccount === true) {
+                    loginData = await hsApi.guestLogin("Hydrogen", {log}).response();
+                } else {
+                    loginData = await hsApi.passwordLogin(username, password, "Hydrogen", {log}).response();
+                }
                 const sessionId = this.createNewSessionId();
                 sessionInfo = {
                     id: sessionId,
@@ -117,7 +128,8 @@ export class SessionContainer {
                     userId: loginData.user_id,
                     homeServer: homeServer,
                     accessToken: loginData.access_token,
-                    lastUsed: clock.now()
+                    lastUsed: clock.now(),
+                    guestAccount: this._guestAccount
                 };
                 log.set("id", sessionId);
                 await this._platform.sessionInfoStorage.add(sessionInfo);            
@@ -156,6 +168,7 @@ export class SessionContainer {
     async _loadSessionInfo(sessionInfo, isNewLogin, log) {
         log.set("appVersion", this._platform.version);
         const clock = this._platform.clock;
+        this._guestAccount = !!sessionInfo.guestAccount;
         this._sessionStartedByReconnector = false;
         this._status.set(LoadStatus.Loading);
         this._reconnector = new Reconnector({
@@ -168,6 +181,7 @@ export class SessionContainer {
             accessToken: sessionInfo.accessToken,
             request: this._platform.request,
             reconnector: this._reconnector,
+            guestAccount: this._guestAccount,
         });
         this._sessionId = sessionInfo.id;
         this._storage = await this._platform.storageFactory.create(sessionInfo.id);
@@ -183,7 +197,7 @@ export class SessionContainer {
         if (this._workerPromise) {
             olmWorker = await this._workerPromise;
         }
-        this._requestScheduler = new RequestScheduler({hsApi, clock});
+        this._requestScheduler = new RequestScheduler({hsApi, clock, guestAccount: this._guestAccount});
         this._requestScheduler.start();
         const mediaRepository = new MediaRepository({
             homeServer: sessionInfo.homeServer,

src/matrix/Sync.js

@@ -181,7 +181,7 @@ export class Sync {
 
     async _syncRequest(syncToken, timeout, log) {
         let {syncFilterId} = this._session;
-        if (typeof syncFilterId !== "string") {
+        if (typeof syncFilterId !== "string" && !this._hsApi._scheduler._guestAccount) {
             this._currentRequest = this._hsApi.createFilter(this._session.user.id, {room: {state: {lazy_load_members: true}}}, {log});
             syncFilterId = (await this._currentRequest.response()).filter_id;
         }

src/matrix/net/HomeServerApi.js

@@ -19,13 +19,14 @@ import {encodeQueryParams, encodeBody} from "./common.js";
 import {HomeServerRequest} from "./HomeServerRequest.js";
 
 export class HomeServerApi {
-    constructor({homeServer, accessToken, request, reconnector}) {
+    constructor({homeServer, accessToken, request, reconnector, guestAccount = false}) {
         // store these both in a closure somehow so it's harder to get at in case of XSS?
         // one could change the homeserver as well so the token gets sent there, so both must be protected from read/write
         this._homeserver = homeServer;
         this._accessToken = accessToken;
         this._requestFn = request;
         this._reconnector = reconnector;
+        this._guestAccount = guestAccount;
     }
 
     _url(csPath) {
@@ -104,6 +105,10 @@ export class HomeServerApi {
     }
 
     sync(since, filter, timeout, options = null) {
+        const _filter =  {room: {state: {lazy_load_members: true}}};
+        if (this._isGuestAccount()) {
+            filter = _filter;
+        }
         return this._get("/sync", {since, timeout, filter}, null, options);
     }
 
@@ -126,8 +131,11 @@ export class HomeServerApi {
     }
 
     receipt(roomId, receiptType, eventId, options = null) {
-        return this._post(`/rooms/${encodeURIComponent(roomId)}/receipt/${encodeURIComponent(receiptType)}/${encodeURIComponent(eventId)}`,
+        if(!this._isGuestAccount()) {
-            {}, {}, options);
+            return this._post(`/rooms/${encodeURIComponent(roomId)}/receipt/${encodeURIComponent(receiptType)}/${encodeURIComponent(eventId)}`,
+                {}, {}, options);
+        }
+        return {response: () => Promise.resolve(null)};
     }
 
     passwordLogin(username, password, initialDeviceDisplayName, options = null) {
@@ -142,6 +150,12 @@ export class HomeServerApi {
         }, options);
     }
 
+    guestLogin(initialDeviceDisplayName, options = null) {
+        return this._unauthedRequest("POST", this._url(`/register`), {kind: 'guest'}, {
+            "initial_device_display_name": initialDeviceDisplayName
+        }, options);
+    }
+
     createFilter(userId, filter, options = null) {
         return this._post(`/user/${encodeURIComponent(userId)}/filter`, null, filter, options);
     }
@@ -205,6 +219,10 @@ export class HomeServerApi {
     forget(roomId, options = null) {
         return this._post(`/rooms/${encodeURIComponent(roomId)}/forget`, null, null, options);
     }
+
+    _isGuestAccount() {
+        return this._guestAccount;
+    }
 }
 
 import {Request as MockRequest} from "../../mocks/Request.js";

src/matrix/net/RequestScheduler.js

@@ -60,13 +60,14 @@ for (const methodName of Object.getOwnPropertyNames(HomeServerApi.prototype)) {
 }
 
 export class RequestScheduler {
-    constructor({hsApi, clock}) {
+    constructor({hsApi, clock, guestAccount = false}) {
         this._hsApi = hsApi;
         this._clock = clock;
         this._requests = new Set();
         this._isRateLimited = false;
         this._isDrainingRateLimit = false;
         this._stopped = true;
+        this._guestAccount = guestAccount;
         this._wrapper = new HomeServerApiWrapper(this);
     }