1 | "use strict";
|
2 | import 'source-map-support/register';
|
3 | const sdk = require("../..");
|
4 | const RoomMember = sdk.RoomMember;
|
5 | const utils = require("../test-utils");
|
6 |
|
7 | import expect from 'expect';
|
8 |
|
9 | describe("RoomMember", function() {
|
10 | const roomId = "!foo:bar";
|
11 | const userA = "@alice:bar";
|
12 | const userB = "@bertha:bar";
|
13 | const userC = "@clarissa:bar";
|
14 | let member;
|
15 |
|
16 | beforeEach(function() {
|
17 | utils.beforeEach(this);
|
18 | member = new RoomMember(roomId, userA);
|
19 | });
|
20 |
|
21 | describe("getAvatarUrl", function() {
|
22 | const hsUrl = "https://my.home.server";
|
23 |
|
24 | it("should return the URL from m.room.member preferentially", function() {
|
25 | member.events.member = utils.mkEvent({
|
26 | event: true,
|
27 | type: "m.room.member",
|
28 | skey: userA,
|
29 | room: roomId,
|
30 | user: userA,
|
31 | content: {
|
32 | membership: "join",
|
33 | avatar_url: "mxc://flibble/wibble",
|
34 | },
|
35 | });
|
36 | const url = member.getAvatarUrl(hsUrl);
|
37 |
|
38 |
|
39 | expect(url.indexOf("flibble/wibble")).toNotEqual(-1);
|
40 | });
|
41 |
|
42 | it("should return an identicon HTTP URL if allowDefault was set and there " +
|
43 | "was no m.room.member event", function() {
|
44 | const url = member.getAvatarUrl(hsUrl, 64, 64, "crop", true);
|
45 | expect(url.indexOf("http")).toEqual(0);
|
46 | });
|
47 |
|
48 | it("should return nothing if there is no m.room.member and allowDefault=false",
|
49 | function() {
|
50 | const url = member.getAvatarUrl(hsUrl, 64, 64, "crop", false);
|
51 | expect(url).toEqual(null);
|
52 | });
|
53 | });
|
54 |
|
55 | describe("setPowerLevelEvent", function() {
|
56 | it("should set 'powerLevel' and 'powerLevelNorm'.", function() {
|
57 | const event = utils.mkEvent({
|
58 | type: "m.room.power_levels",
|
59 | room: roomId,
|
60 | user: userA,
|
61 | content: {
|
62 | users_default: 20,
|
63 | users: {
|
64 | "@bertha:bar": 200,
|
65 | "@invalid:user": 10,
|
66 | },
|
67 | },
|
68 | event: true,
|
69 | });
|
70 | member.setPowerLevelEvent(event);
|
71 | expect(member.powerLevel).toEqual(20);
|
72 | expect(member.powerLevelNorm).toEqual(10);
|
73 |
|
74 | const memberB = new RoomMember(roomId, userB);
|
75 | memberB.setPowerLevelEvent(event);
|
76 | expect(memberB.powerLevel).toEqual(200);
|
77 | expect(memberB.powerLevelNorm).toEqual(100);
|
78 | });
|
79 |
|
80 | it("should emit 'RoomMember.powerLevel' if the power level changes.",
|
81 | function() {
|
82 | const event = utils.mkEvent({
|
83 | type: "m.room.power_levels",
|
84 | room: roomId,
|
85 | user: userA,
|
86 | content: {
|
87 | users_default: 20,
|
88 | users: {
|
89 | "@bertha:bar": 200,
|
90 | "@invalid:user": 10,
|
91 | },
|
92 | },
|
93 | event: true,
|
94 | });
|
95 | let emitCount = 0;
|
96 |
|
97 | member.on("RoomMember.powerLevel", function(emitEvent, emitMember) {
|
98 | emitCount += 1;
|
99 | expect(emitMember).toEqual(member);
|
100 | expect(emitEvent).toEqual(event);
|
101 | });
|
102 |
|
103 | member.setPowerLevelEvent(event);
|
104 | expect(emitCount).toEqual(1);
|
105 | member.setPowerLevelEvent(event);
|
106 | expect(emitCount).toEqual(1);
|
107 | });
|
108 |
|
109 | it("should honour power levels of zero.",
|
110 | function() {
|
111 | const event = utils.mkEvent({
|
112 | type: "m.room.power_levels",
|
113 | room: roomId,
|
114 | user: userA,
|
115 | content: {
|
116 | users_default: 20,
|
117 | users: {
|
118 | "@alice:bar": 0,
|
119 | },
|
120 | },
|
121 | event: true,
|
122 | });
|
123 | let emitCount = 0;
|
124 |
|
125 |
|
126 |
|
127 | member.powerLevel = 1;
|
128 | member.on("RoomMember.powerLevel", function(emitEvent, emitMember) {
|
129 | emitCount += 1;
|
130 | expect(emitMember.userId).toEqual('@alice:bar');
|
131 | expect(emitMember.powerLevel).toEqual(0);
|
132 | expect(emitEvent).toEqual(event);
|
133 | });
|
134 |
|
135 | member.setPowerLevelEvent(event);
|
136 | expect(member.powerLevel).toEqual(0);
|
137 | expect(emitCount).toEqual(1);
|
138 | });
|
139 | });
|
140 |
|
141 | describe("setTypingEvent", function() {
|
142 | it("should set 'typing'", function() {
|
143 | member.typing = false;
|
144 | const memberB = new RoomMember(roomId, userB);
|
145 | memberB.typing = true;
|
146 | const memberC = new RoomMember(roomId, userC);
|
147 | memberC.typing = true;
|
148 |
|
149 | const event = utils.mkEvent({
|
150 | type: "m.typing",
|
151 | user: userA,
|
152 | room: roomId,
|
153 | content: {
|
154 | user_ids: [
|
155 | userA, userC,
|
156 | ],
|
157 | },
|
158 | event: true,
|
159 | });
|
160 | member.setTypingEvent(event);
|
161 | memberB.setTypingEvent(event);
|
162 | memberC.setTypingEvent(event);
|
163 |
|
164 | expect(member.typing).toEqual(true);
|
165 | expect(memberB.typing).toEqual(false);
|
166 | expect(memberC.typing).toEqual(true);
|
167 | });
|
168 |
|
169 | it("should emit 'RoomMember.typing' if the typing state changes",
|
170 | function() {
|
171 | const event = utils.mkEvent({
|
172 | type: "m.typing",
|
173 | room: roomId,
|
174 | content: {
|
175 | user_ids: [
|
176 | userA, userC,
|
177 | ],
|
178 | },
|
179 | event: true,
|
180 | });
|
181 | let emitCount = 0;
|
182 | member.on("RoomMember.typing", function(ev, mem) {
|
183 | expect(mem).toEqual(member);
|
184 | expect(ev).toEqual(event);
|
185 | emitCount += 1;
|
186 | });
|
187 | member.typing = false;
|
188 | member.setTypingEvent(event);
|
189 | expect(emitCount).toEqual(1);
|
190 | member.setTypingEvent(event);
|
191 | expect(emitCount).toEqual(1);
|
192 | });
|
193 | });
|
194 |
|
195 | describe("isOutOfBand", function() {
|
196 | it("should be set by markOutOfBand", function() {
|
197 | const member = new RoomMember();
|
198 | expect(member.isOutOfBand()).toEqual(false);
|
199 | member.markOutOfBand();
|
200 | expect(member.isOutOfBand()).toEqual(true);
|
201 | });
|
202 | });
|
203 |
|
204 | describe("setMembershipEvent", function() {
|
205 | const joinEvent = utils.mkMembership({
|
206 | event: true,
|
207 | mship: "join",
|
208 | user: userA,
|
209 | room: roomId,
|
210 | name: "Alice",
|
211 | });
|
212 |
|
213 | const inviteEvent = utils.mkMembership({
|
214 | event: true,
|
215 | mship: "invite",
|
216 | user: userB,
|
217 | skey: userA,
|
218 | room: roomId,
|
219 | });
|
220 |
|
221 | it("should set 'membership' and assign the event to 'events.member'.",
|
222 | function() {
|
223 | member.setMembershipEvent(inviteEvent);
|
224 | expect(member.membership).toEqual("invite");
|
225 | expect(member.events.member).toEqual(inviteEvent);
|
226 | member.setMembershipEvent(joinEvent);
|
227 | expect(member.membership).toEqual("join");
|
228 | expect(member.events.member).toEqual(joinEvent);
|
229 | });
|
230 |
|
231 | it("should set 'name' based on user_id, displayname and room state",
|
232 | function() {
|
233 | const roomState = {
|
234 | getStateEvents: function(type) {
|
235 | if (type !== "m.room.member") {
|
236 | return [];
|
237 | }
|
238 | return [
|
239 | utils.mkMembership({
|
240 | event: true, mship: "join", room: roomId,
|
241 | user: userB,
|
242 | }),
|
243 | utils.mkMembership({
|
244 | event: true, mship: "join", room: roomId,
|
245 | user: userC, name: "Alice",
|
246 | }),
|
247 | joinEvent,
|
248 | ];
|
249 | },
|
250 | getUserIdsWithDisplayName: function(displayName) {
|
251 | return [userA, userC];
|
252 | },
|
253 | };
|
254 | expect(member.name).toEqual(userA);
|
255 | member.setMembershipEvent(joinEvent);
|
256 | expect(member.name).toEqual("Alice");
|
257 | member.setMembershipEvent(joinEvent, roomState);
|
258 | expect(member.name).toNotEqual("Alice");
|
259 |
|
260 | expect(member.name.indexOf(userA)).toNotEqual(-1);
|
261 | });
|
262 |
|
263 | it("should emit 'RoomMember.membership' if the membership changes", function() {
|
264 | let emitCount = 0;
|
265 | member.on("RoomMember.membership", function(ev, mem) {
|
266 | emitCount += 1;
|
267 | expect(mem).toEqual(member);
|
268 | expect(ev).toEqual(inviteEvent);
|
269 | });
|
270 | member.setMembershipEvent(inviteEvent);
|
271 | expect(emitCount).toEqual(1);
|
272 | member.setMembershipEvent(inviteEvent);
|
273 | expect(emitCount).toEqual(1);
|
274 | });
|
275 |
|
276 | it("should emit 'RoomMember.name' if the name changes", function() {
|
277 | let emitCount = 0;
|
278 | member.on("RoomMember.name", function(ev, mem) {
|
279 | emitCount += 1;
|
280 | expect(mem).toEqual(member);
|
281 | expect(ev).toEqual(joinEvent);
|
282 | });
|
283 | member.setMembershipEvent(joinEvent);
|
284 | expect(emitCount).toEqual(1);
|
285 | member.setMembershipEvent(joinEvent);
|
286 | expect(emitCount).toEqual(1);
|
287 | });
|
288 |
|
289 | it("should set 'name' to user_id if it is just whitespace", function() {
|
290 | const joinEvent = utils.mkMembership({
|
291 | event: true,
|
292 | mship: "join",
|
293 | user: userA,
|
294 | room: roomId,
|
295 | name: " \u200b ",
|
296 | });
|
297 |
|
298 | expect(member.name).toEqual(userA);
|
299 | member.setMembershipEvent(joinEvent);
|
300 | expect(member.name).toEqual(userA);
|
301 | });
|
302 |
|
303 | it("should disambiguate users on a fuzzy displayname match", function() {
|
304 | const joinEvent = utils.mkMembership({
|
305 | event: true,
|
306 | mship: "join",
|
307 | user: userA,
|
308 | room: roomId,
|
309 | name: "Alíce\u200b",
|
310 | });
|
311 |
|
312 | const roomState = {
|
313 | getStateEvents: function(type) {
|
314 | if (type !== "m.room.member") {
|
315 | return [];
|
316 | }
|
317 | return [
|
318 | utils.mkMembership({
|
319 | event: true, mship: "join", room: roomId,
|
320 | user: userC, name: "Alice",
|
321 | }),
|
322 | joinEvent,
|
323 | ];
|
324 | },
|
325 | getUserIdsWithDisplayName: function(displayName) {
|
326 | return [userA, userC];
|
327 | },
|
328 | };
|
329 | expect(member.name).toEqual(userA);
|
330 | member.setMembershipEvent(joinEvent, roomState);
|
331 | expect(member.name).toNotEqual("Alíce");
|
332 |
|
333 | expect(member.name.indexOf(userA)).toNotEqual(-1);
|
334 | });
|
335 | });
|
336 | });
|