Merge branch 'develop' of github.com:matrix-org/matrix-react-sdk into t3chguy/fix/17686

 Conflicts:

	src/components/views/dialogs/CreateRoomDialog.tsx

	src/components/views/dialogs/RoomUpgradeDialog.tsx

	src/components/views/dialogs/RoomUpgradeWarningDialog.tsx

	src/components/views/settings/tabs/room/SecurityRoomSettingsTab.tsx

test/accessibility/RovingTabIndex-test.js

@@ -48,7 +48,7 @@ const button4 = <Button key={4}>d</Button>;
 describe("RovingTabIndex", () => {
     it("RovingTabIndexProvider renders children as expected", () => {
         const wrapper = mount(<RovingTabIndexProvider>
-            {() => <div><span>Test</span></div>}
+            { () => <div><span>Test</span></div> }
         </RovingTabIndexProvider>);
         expect(wrapper.text()).toBe("Test");
         expect(wrapper.html()).toBe('<div><span>Test</span></div>');
@@ -56,11 +56,11 @@ describe("RovingTabIndex", () => {
 
     it("RovingTabIndexProvider works as expected with useRovingTabIndex", () => {
         const wrapper = mount(<RovingTabIndexProvider>
-            {() => <React.Fragment>
+            { () => <React.Fragment>
                 { button1 }
                 { button2 }
                 { button3 }
-            </React.Fragment>}
+            </React.Fragment> }
         </RovingTabIndexProvider>);
 
         // should begin with 0th being active
@@ -98,15 +98,15 @@ describe("RovingTabIndex", () => {
 
     it("RovingTabIndexProvider works as expected with RovingTabIndexWrapper", () => {
         const wrapper = mount(<RovingTabIndexProvider>
-            {() => <React.Fragment>
+            { () => <React.Fragment>
                 { button1 }
                 { button2 }
                 <RovingTabIndexWrapper>
-                    {({ onFocus, isActive, ref }) =>
+                    { ({ onFocus, isActive, ref }) =>
                         <button onFocus={onFocus} tabIndex={isActive ? 0 : -1} ref={ref}>.</button>
                     }
                 </RovingTabIndexWrapper>
-            </React.Fragment>}
+            </React.Fragment> }
         </RovingTabIndexProvider>);
 
         // should begin with 0th being active

test/components/structures/CallEventGrouper-test.ts

@@ -0,0 +1,140 @@
+/*
+Copyright 2021 Šimon Brandner <simon.bra.ag@gmail.com>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import "../../skinned-sdk";
+import { stubClient } from '../../test-utils';
+import { MatrixClientPeg } from '../../../src/MatrixClientPeg';
+import { MatrixClient } from 'matrix-js-sdk';
+import { EventType } from "matrix-js-sdk/src/@types/event";
+import CallEventGrouper, { CustomCallState } from "../../../src/components/structures/CallEventGrouper";
+import { CallState } from "matrix-js-sdk/src/webrtc/call";
+
+const MY_USER_ID = "@me:here";
+const THEIR_USER_ID = "@they:here";
+
+let client: MatrixClient;
+
+describe('CallEventGrouper', () => {
+    beforeEach(() => {
+        stubClient();
+        client = MatrixClientPeg.get();
+        client.getUserId = () => {
+            return MY_USER_ID;
+        };
+    });
+
+    it("detects a missed call", () => {
+        const grouper = new CallEventGrouper();
+
+        grouper.add({
+            getContent: () => {
+                return {
+                    call_id: "callId",
+                };
+            },
+            getType: () => {
+                return EventType.CallInvite;
+            },
+            sender: {
+                userId: THEIR_USER_ID,
+            },
+        });
+
+        expect(grouper.state).toBe(CustomCallState.Missed);
+    });
+
+    it("detects an ended call", () => {
+        const grouperHangup = new CallEventGrouper();
+        const grouperReject = new CallEventGrouper();
+
+        grouperHangup.add({
+            getContent: () => {
+                return {
+                    call_id: "callId",
+                };
+            },
+            getType: () => {
+                return EventType.CallInvite;
+            },
+            sender: {
+                userId: MY_USER_ID,
+            },
+        });
+        grouperHangup.add({
+            getContent: () => {
+                return {
+                    call_id: "callId",
+                };
+            },
+            getType: () => {
+                return EventType.CallHangup;
+            },
+            sender: {
+                userId: THEIR_USER_ID,
+            },
+        });
+
+        grouperReject.add({
+            getContent: () => {
+                return {
+                    call_id: "callId",
+                };
+            },
+            getType: () => {
+                return EventType.CallInvite;
+            },
+            sender: {
+                userId: MY_USER_ID,
+            },
+        });
+        grouperReject.add({
+            getContent: () => {
+                return {
+                    call_id: "callId",
+                };
+            },
+            getType: () => {
+                return EventType.CallReject;
+            },
+            sender: {
+                userId: THEIR_USER_ID,
+            },
+        });
+
+        expect(grouperHangup.state).toBe(CallState.Ended);
+        expect(grouperReject.state).toBe(CallState.Ended);
+    });
+
+    it("detects call type", () => {
+        const grouper = new CallEventGrouper();
+
+        grouper.add({
+            getContent: () => {
+                return {
+                    call_id: "callId",
+                    offer: {
+                        sdp: "this is definitely an SDP m=video",
+                    },
+                };
+            },
+            getType: () => {
+                return EventType.CallInvite;
+            },
+        });
+
+        expect(grouper.isVoice).toBe(false);
+    });
+});

test/createRoom-test.js

@@ -1,5 +1,5 @@
 import './skinned-sdk'; // Must be first for skinning to work
-import { _waitForMember, canEncryptToAllUsers } from '../src/createRoom';
+import { waitForMember, canEncryptToAllUsers } from '../src/createRoom';
 import { EventEmitter } from 'events';
 
 /* Shorter timeout, we've got tests to run */
@@ -13,7 +13,7 @@ describe("waitForMember", () => {
     });
 
     it("resolves with false if the timeout is reached", (done) => {
-        _waitForMember(client, "", "", { timeout: 0 }).then((r) => {
+        waitForMember(client, "", "", { timeout: 0 }).then((r) => {
             expect(r).toBe(false);
             done();
         });
@@ -22,7 +22,7 @@ describe("waitForMember", () => {
     it("resolves with false if the timeout is reached, even if other RoomState.newMember events fire", (done) => {
         const roomId = "!roomId:domain";
         const userId = "@clientId:domain";
-        _waitForMember(client, roomId, userId, { timeout }).then((r) => {
+        waitForMember(client, roomId, userId, { timeout }).then((r) => {
             expect(r).toBe(false);
             done();
         });
@@ -32,7 +32,7 @@ describe("waitForMember", () => {
     it("resolves with true if RoomState.newMember fires", (done) => {
         const roomId = "!roomId:domain";
         const userId = "@clientId:domain";
-        _waitForMember(client, roomId, userId, { timeout }).then((r) => {
+        waitForMember(client, roomId, userId, { timeout }).then((r) => {
             expect(r).toBe(true);
             expect(client.listeners("RoomState.newMember").length).toBe(0);
             done();