sipwise
/
jitsi
mirror of https://github.com/sipwise/jitsi.git
1
0
Fork 0
Code Issues Releases Wiki Activity

- Moved setUserRole() to setLocalUserRole()

Browse Source 
- Updated room member roles (distinct from "affiliation")
- Enabled unit test for Jabber chatrooms *roles*
cusax-fix
Valentin Martinet 16 years ago
parent 71f0f1a7b8
commit ee7a1a6a25
6 changed files with 184 additions and 141 deletions
Show Stats Download Patch File Download Diff File

3
src/net/java/sip/communicator/impl/protocol/irc/ChatRoomIrcImpl.java
Unescape View File

@ -959,6 +959,7 @@ public void fireMemberPresenceEvent(ChatRoomMember member,
public void fireMemberRoleEvent( ChatRoomMember member, public void fireMemberRoleEvent( ChatRoomMember member,
ChatRoomMemberRole newRole) ChatRoomMemberRole newRole)
{ {
member.setRole(newRole);
ChatRoomMemberRole previousRole = member.getRole(); ChatRoomMemberRole previousRole = member.getRole();
ChatRoomMemberRoleChangeEvent evt ChatRoomMemberRoleChangeEvent evt
@ -1069,7 +1070,7 @@ public ChatRoomMemberRole getUserRole()
* @param role the role to set * @param role the role to set
* @throws OperationFailedException if the operation don't succeed * @throws OperationFailedException if the operation don't succeed
*/ */
public void setUserRole(ChatRoomMemberRole role) public void setLocalUserRole(ChatRoomMemberRole role)
throws OperationFailedException throws OperationFailedException
{ {
throw new UnsupportedOperationException("Not supported yet."); throw new UnsupportedOperationException("Not supported yet.");

27
src/net/java/sip/communicator/impl/protocol/jabber/ChatRoomJabberImpl.java
Unescape View File

@ -846,7 +846,7 @@ public ChatRoomMemberRole getUserRole()
* *
* @param role the new role to be set for the local user * @param role the new role to be set for the local user
*/ */
public void setUserRole(ChatRoomMemberRole role) public void setLocalUserRole(ChatRoomMemberRole role)
{ {
fireLocalUserRoleEvent(getUserRole(), role); fireLocalUserRoleEvent(getUserRole(), role);
this.role = role; this.role = role;
@ -1151,7 +1151,7 @@ public void moderatorRevoked(String participant)
return; return;
fireMemberRoleEvent(member, member.getRole(), fireMemberRoleEvent(member, member.getRole(),
ChatRoomMemberRole.GUEST); ChatRoomMemberRole.MEMBER);
} }
/** /**
@ -1170,7 +1170,7 @@ public void voiceGranted(String participant)
return; return;
fireMemberRoleEvent(member, member.getRole(), fireMemberRoleEvent(member, member.getRole(),
ChatRoomMemberRole.GUEST); ChatRoomMemberRole.MEMBER);
} }
/** /**
@ -1479,6 +1479,7 @@ private void fireMemberPresenceEvent(ChatRoomMember member,
private void fireMemberRoleEvent(ChatRoomMember member, private void fireMemberRoleEvent(ChatRoomMember member,
ChatRoomMemberRole previousRole, ChatRoomMemberRole newRole) ChatRoomMemberRole previousRole, ChatRoomMemberRole newRole)
{ {
member.setRole(newRole);
ChatRoomMemberRoleChangeEvent evt ChatRoomMemberRoleChangeEvent evt
= new ChatRoomMemberRoleChangeEvent( = new ChatRoomMemberRoleChangeEvent(
this, member, previousRole, newRole); this, member, previousRole, newRole);
@ -1670,7 +1671,7 @@ public void kicked(String actor, String reason)
*/ */
public void voiceGranted() public void voiceGranted()
{ {
setUserRole(ChatRoomMemberRole.MEMBER); setLocalUserRole(ChatRoomMemberRole.MEMBER);
} }
/** /**
@ -1680,7 +1681,7 @@ public void voiceGranted()
*/ */
public void voiceRevoked() public void voiceRevoked()
{ {
setUserRole(ChatRoomMemberRole.SILENT_MEMBER); setLocalUserRole(ChatRoomMemberRole.SILENT_MEMBER);
} }
/** /**
@ -1705,7 +1706,7 @@ public void banned(String actor, String reason)
*/ */
public void membershipGranted() public void membershipGranted()
{ {
setUserRole(ChatRoomMemberRole.MEMBER); setLocalUserRole(ChatRoomMemberRole.MEMBER);
} }
/** /**
@ -1714,7 +1715,7 @@ public void membershipGranted()
*/ */
public void membershipRevoked() public void membershipRevoked()
{ {
setUserRole(ChatRoomMemberRole.GUEST); setLocalUserRole(ChatRoomMemberRole.GUEST);
} }
/** /**
@ -1725,7 +1726,7 @@ public void membershipRevoked()
*/ */
public void moderatorGranted() public void moderatorGranted()
{ {
setUserRole(ChatRoomMemberRole.MODERATOR); setLocalUserRole(ChatRoomMemberRole.MODERATOR);
} }
/** /**
@ -1736,7 +1737,7 @@ public void moderatorGranted()
*/ */
public void moderatorRevoked() public void moderatorRevoked()
{ {
setUserRole(ChatRoomMemberRole.MEMBER); setLocalUserRole(ChatRoomMemberRole.MEMBER);
} }
/** /**
@ -1746,7 +1747,7 @@ public void moderatorRevoked()
*/ */
public void ownershipGranted() public void ownershipGranted()
{ {
setUserRole(ChatRoomMemberRole.OWNER); setLocalUserRole(ChatRoomMemberRole.OWNER);
} }
/** /**
@ -1756,7 +1757,7 @@ public void ownershipGranted()
*/ */
public void ownershipRevoked() public void ownershipRevoked()
{ {
setUserRole(ChatRoomMemberRole.ADMINISTRATOR); setLocalUserRole(ChatRoomMemberRole.ADMINISTRATOR);
} }
/** /**
@ -1766,7 +1767,7 @@ public void ownershipRevoked()
*/ */
public void adminGranted() public void adminGranted()
{ {
setUserRole(ChatRoomMemberRole.ADMINISTRATOR); setLocalUserRole(ChatRoomMemberRole.ADMINISTRATOR);
} }
/** /**
@ -1776,7 +1777,7 @@ public void adminGranted()
*/ */
public void adminRevoked() public void adminRevoked()
{ {
setUserRole(ChatRoomMemberRole.MEMBER); setLocalUserRole(ChatRoomMemberRole.MEMBER);
} }
} }

2
src/net/java/sip/communicator/impl/protocol/jabber/OperationSetMultiUserChatJabberImpl.java
Unescape View File

@ -122,7 +122,7 @@ public ChatRoom createChatRoom(
, ex.getCause()); , ex.getCause());
} }
room = createLocalChatRoomInstance(muc); room = createLocalChatRoomInstance(muc);
room.setUserRole(ChatRoomMemberRole.MODERATOR); room.setLocalUserRole(ChatRoomMemberRole.MODERATOR);
} }
return room; return room;
} }

2
src/net/java/sip/communicator/impl/protocol/mock/MockChatRoom.java
Unescape View File

@ -748,7 +748,7 @@ public ChatRoomMemberRole getUserRole()
* @param role the role to set * @param role the role to set
* @throws OperationFailedException if the operation don't succeed * @throws OperationFailedException if the operation don't succeed
*/ */
public void setUserRole(ChatRoomMemberRole role) public void setLocalUserRole(ChatRoomMemberRole role)
throws OperationFailedException throws OperationFailedException
{ {
throw new UnsupportedOperationException("Not supported yet."); throw new UnsupportedOperationException("Not supported yet.");

2
src/net/java/sip/communicator/service/protocol/ChatRoom.java
Unescape View File

@ -158,7 +158,7 @@ public void setSubject(String subject)
* *
* @throws OperationFailedException if an error occurs. * @throws OperationFailedException if an error occurs.
*/ */
public void setUserRole(ChatRoomMemberRole role) public void setLocalUserRole(ChatRoomMemberRole role)
throws OperationFailedException; throws OperationFailedException;
/** /**

289
test/net/java/sip/communicator/slick/protocol/jabber/TestOperationSetMultiUserChat2.java
Unescape View File

@ -368,24 +368,24 @@ public static Test suite()
* administrative rights are revoked by owner/admin of the room. * administrative rights are revoked by owner/admin of the room.
* *
*/ */
// suite.addTest( suite.addTest(
// new TestOperationSetMultiUserChat2("testInitialParticipantsRoles")); new TestOperationSetMultiUserChat2("testInitialParticipantsRoles"));
//
// suite.addTest( //suite.addTest(
// new TestOperationSetMultiUserChat2("testRevokeMembership")); // new TestOperationSetMultiUserChat2("testRevokeMembership"));
//
// suite.addTest( //suite.addTest(
// new TestOperationSetMultiUserChat2("testGrantMembership")); // new TestOperationSetMultiUserChat2("testGrantMembership"));
//
// suite.addTest(new TestOperationSetMultiUserChat2("testGrantModerator")); suite.addTest(new TestOperationSetMultiUserChat2("testGrantModerator"));
//
// suite.addTest(new TestOperationSetMultiUserChat2("testRevokeVoice")); suite.addTest(new TestOperationSetMultiUserChat2("testRevokeVoice"));
//
// suite.addTest(new TestOperationSetMultiUserChat2("testGrantVoice")); suite.addTest(new TestOperationSetMultiUserChat2("testGrantVoice"));
//
// suite.addTest( suite.addTest(
// new TestOperationSetMultiUserChat2("testRevokeModerator")); new TestOperationSetMultiUserChat2("testRevokeModerator"));
//
// suite.addTest(new TestOperationSetMultiUserChat2("testGrantAdmin")); // suite.addTest(new TestOperationSetMultiUserChat2("testGrantAdmin"));
// //
// suite.addTest(new TestOperationSetMultiUserChat2("testGrantOwnership")); // suite.addTest(new TestOperationSetMultiUserChat2("testGrantOwnership"));
@ -1252,7 +1252,7 @@ public void testMemberKick()
public void testInitialParticipantsRoles() public void testInitialParticipantsRoles()
throws OperationFailedException, OperationNotSupportedException throws OperationFailedException, OperationNotSupportedException
{ {
String roomName = testRoomBaseName + roomID++; String roomName = testRoomBaseName + roomID;
// We create the test room // We create the test room
ChatRoom roomUser1 = opSetMUC1.createChatRoom(roomName, null); ChatRoom roomUser1 = opSetMUC1.createChatRoom(roomName, null);
@ -1263,20 +1263,20 @@ public void testInitialParticipantsRoles()
// User1 who just created the room is supposed to be the owner: // User1 who just created the room is supposed to be the owner:
assertEquals("Unexpected role for user1", assertEquals("Unexpected role for user1",
roomUser1.getUserRole(), ChatRoomMemberRole.OWNER); roomUser1.getUserRole(), ChatRoomMemberRole.MODERATOR);
assertEquals("Unexpected role for user1", roomUser1.getUserRole(),
roomUser1.getMembers().remove(0).getRole());
// Both of our peers join the room: // Both of our peers join the room:
ChatRoom roomUser2 = opSetMUC2.findRoom(roomName); ChatRoom roomUser2 = opSetMUC2.findRoom(roomName);
assertNotNull("Room can't be retrieved on user2's side", roomUser2); assertNotNull("Room can't be retrieved on user2's side", roomUser2);
roomUser2.join(); roomUser2.join();
roomUser1Collector.waitForEvent(10000); // wait for user2
ChatRoom roomUser3 = opSetMUC3.findRoom(roomName); ChatRoom roomUser3 = opSetMUC3.findRoom(roomName);
assertNotNull("Room can't be retrieved on user3's side", roomUser2); assertNotNull("Room can't be retrieved on user3's side", roomUser2);
roomUser3.join(); roomUser3.join();
roomUser1Collector.waitForEvent(10000); // wait for user3
// Wait for our peers:
roomUser1Collector.waitForEvent(10000);
roomUser1Collector.waitForEvent(10000);
assertTrue("User2 not on member list after having join the room" assertTrue("User2 not on member list after having join the room"
, nameIsOnMemberList(fixture.userID2, roomUser1.getMembers())); , nameIsOnMemberList(fixture.userID2, roomUser1.getMembers()));
@ -1285,17 +1285,18 @@ public void testInitialParticipantsRoles()
List<ChatRoomMember> members = roomUser1.getMembers(); List<ChatRoomMember> members = roomUser1.getMembers();
// Two members are supposed to be in the room: // Three members are supposed to be in the room:
assertTrue("Unexpected members count", members.size() == 2); assertEquals("Unexpected members count", 3, members.size());
// We are sure these members are our peers (checked before the last // We are sure two of these members are our peers (checked before the
// test), now we make sure they are both members: // last assertion), now we make sure they are both members:
// (Note that the first element of the list refers to the owner)
assertEquals("The current implementation requires that room's new " + assertEquals("The current implementation requires that room's new " +
"comers must have MEMBER role", "comers must have MEMBER role",
ChatRoomMemberRole.MEMBER, members.get(0).getRole()); ChatRoomMemberRole.MEMBER, members.get(1).getRole());
assertEquals("The current implementation requires that room's new " + assertEquals("The current implementation requires that room's new " +
"comers must have the MEMBER role", "comers must have the MEMBER role",
ChatRoomMemberRole.MEMBER, members.get(1).getRole()); ChatRoomMemberRole.MEMBER, members.get(2).getRole());
} }
/** /**
@ -1340,17 +1341,26 @@ public void testGrantMembership()
(ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID2, fixture.userID2,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User2's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.GUEST); ChatRoomMemberRole.GUEST, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.MEMBER); ChatRoomMemberRole.MEMBER, roleEventUser1.getNewRole());
// We finally check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser3); roomName, StringUtils.parseName(
roleEventUser3.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user",
fixture.userID2,
roleEventUser3.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match",
ChatRoomMemberRole.GUEST, roleEventUser3.getPreviousRole());
assertEquals("Unexpected new role",
ChatRoomMemberRole.MEMBER, roleEventUser3.getNewRole());
} }
/** /**
@ -1396,17 +1406,26 @@ public void testGrantModerator()
(ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID2, fixture.userID2,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User2's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.GUEST); ChatRoomMemberRole.MEMBER, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.MODERATOR); ChatRoomMemberRole.MODERATOR, roleEventUser1.getNewRole());
// We finally check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser3); roomName, StringUtils.parseName(
roleEventUser3.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user",
fixture.userID2,
roleEventUser3.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match",
ChatRoomMemberRole.MEMBER, roleEventUser3.getPreviousRole());
assertEquals("Unexpected new role",
ChatRoomMemberRole.MODERATOR, roleEventUser3.getNewRole());
} }
/** /**
@ -1454,31 +1473,26 @@ public void testRevokeVoice()
(ChatRoomMemberRoleChangeEvent) roomUser2Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser2Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID3, fixture.userID3,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User3's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.GUEST); ChatRoomMemberRole.MEMBER, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.SILENT_MEMBER); ChatRoomMemberRole.SILENT_MEMBER, roleEventUser1.getNewRole());
// We check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser2); roomName, StringUtils.parseName(
roleEventUser2.getSourceChatRoom().getName()));
// Now user3 (silent member) will send a message to the room. This assertEquals("Collected event does not belong to the expected user",
// action has to fail because user3 has no more voice right. fixture.userID3,
Message messageUser3 = roomUser3.createMessage("Mute?"); roleEventUser2.getSourceMember().getContactAddress());
try assertEquals("User3's previous role does not match",
{ ChatRoomMemberRole.MEMBER, roleEventUser2.getPreviousRole());
roomUser3.sendMessage(messageUser3); assertEquals("Unexpected new role",
} ChatRoomMemberRole.SILENT_MEMBER, roleEventUser2.getNewRole());
catch (OperationFailedException ofe)
{
// that's what was supposed to happen.
return; // We exit here, otherwise the test fails.
}
fail("User3 may have succeeded to send a message through the room");
} }
/** /**
@ -1502,9 +1516,6 @@ public void testGrantVoice()
ChatRoom roomUser2 = opSetMUC2.findRoom(roomName); ChatRoom roomUser2 = opSetMUC2.findRoom(roomName);
assertNotNull("The room can't be retrieved on user2's side", roomUser2); assertNotNull("The room can't be retrieved on user2's side", roomUser2);
ChatRoom roomUser3 = opSetMUC3.findRoom(roomName);
assertNotNull("The room can't be retrieved on user3's side", roomUser3);
MUCEventCollector roomUser1Col = new MUCEventCollector( MUCEventCollector roomUser1Col = new MUCEventCollector(
roomUser1, MUCEventCollector.EVENT_ROLE); roomUser1, MUCEventCollector.EVENT_ROLE);
MUCEventCollector roomUser2Col = new MUCEventCollector( MUCEventCollector roomUser2Col = new MUCEventCollector(
@ -1527,31 +1538,26 @@ public void testGrantVoice()
(ChatRoomMemberRoleChangeEvent) roomUser2Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser2Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID3, fixture.userID3,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User3's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.SILENT_MEMBER); ChatRoomMemberRole.SILENT_MEMBER, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.GUEST); ChatRoomMemberRole.MEMBER, roleEventUser1.getNewRole());
// We finally check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser2); roomName, StringUtils.parseName(
roleEventUser2.getSourceChatRoom().getName()));
// Now user3 (silent member) will send a message to the room. This assertEquals("Collected event does not belong to the expected user",
// action has to fail because user3 has no more voice right. fixture.userID3,
Message messageUser3 = roomUser3.createMessage("Mute?"); roleEventUser2.getSourceMember().getContactAddress());
try assertEquals("User3's previous role does not match",
{ ChatRoomMemberRole.SILENT_MEMBER, roleEventUser2.getPreviousRole());
roomUser3.sendMessage(messageUser3); assertEquals("Unexpected new role",
} ChatRoomMemberRole.MEMBER, roleEventUser2.getNewRole());
catch (OperationFailedException ofe)
{
// this was not supposed to happen.
fail("User3 didn't succeed to send a message through the room");
}
} }
/** /**
@ -1599,17 +1605,26 @@ public void testGrantAdmin()
(ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID2, fixture.userID2,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User2's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.MEMBER); ChatRoomMemberRole.MEMBER, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.ADMINISTRATOR); ChatRoomMemberRole.ADMINISTRATOR, roleEventUser1.getNewRole());
// We check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser3); roomName, StringUtils.parseName(
roleEventUser3.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user",
fixture.userID2,
roleEventUser3.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match",
ChatRoomMemberRole.MEMBER, roleEventUser3.getPreviousRole());
assertEquals("Unexpected new role",
ChatRoomMemberRole.ADMINISTRATOR, roleEventUser3.getNewRole());
} }
/** /**
@ -1654,17 +1669,26 @@ public void testGrantOwnership()
(ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID2, fixture.userID2,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User2's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.ADMINISTRATOR); ChatRoomMemberRole.ADMINISTRATOR, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.OWNER); ChatRoomMemberRole.OWNER, roleEventUser1.getNewRole());
// We check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser3); roomName, StringUtils.parseName(
roleEventUser3.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user",
fixture.userID2,
roleEventUser3.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match",
ChatRoomMemberRole.ADMINISTRATOR, roleEventUser3.getPreviousRole());
assertEquals("Unexpected new role",
ChatRoomMemberRole.OWNER, roleEventUser3.getNewRole());
} }
/** /**
@ -1686,39 +1710,29 @@ public void testRevokeMembership()
ChatRoom roomUser3 = opSetMUC3.findRoom(roomName); ChatRoom roomUser3 = opSetMUC3.findRoom(roomName);
assertNotNull("The room can't be retrieved on user3's side", roomUser3); assertNotNull("The room can't be retrieved on user3's side", roomUser3);
MUCEventCollector roomUser1Col = new MUCEventCollector(
roomUser1, MUCEventCollector.EVENT_ROLE);
MUCEventCollector roomUser3Col = new MUCEventCollector( MUCEventCollector roomUser3Col = new MUCEventCollector(
roomUser3, MUCEventCollector.EVENT_ROLE); roomUser3, MUCEventCollector.EVENT_ROLE);
// Owner of the room revokes user2 member rights: // Owner of the room revokes user2 member rights:
roomUser1.revokeMembership(fixture.userID2); roomUser1.revokeMembership(fixture.userID2);
roomUser1Col.waitForEvent(10000);
roomUser3Col.waitForEvent(10000); roomUser3Col.waitForEvent(10000);
assertEquals("Wrong count of collected events on user1's side",
1, roomUser1Col.collectedEvents.size());
ChatRoomMemberRoleChangeEvent roleEventUser1 =
(ChatRoomMemberRoleChangeEvent) roomUser1Col.collectedEvents.get(0);
assertEquals("Wrong count of collected events on user3's side", assertEquals("Wrong count of collected events on user3's side",
1, roomUser3Col.collectedEvents.size()); 1, roomUser3Col.collectedEvents.size());
ChatRoomMemberRoleChangeEvent roleEventUser3 = ChatRoomMemberRoleChangeEvent roleEventUser3 =
(ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser3.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID2, fixture.userID2,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser3.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User2's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.MEMBER); ChatRoomMemberRole.MEMBER, roleEventUser3.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.GUEST); ChatRoomMemberRole.GUEST, roleEventUser3.getNewRole());
// We finally check that event is the same on each side:
assertEquals(roleEventUser1, roleEventUser3);
} }
/** /**
@ -1761,17 +1775,26 @@ public void testRevokeModerator()
(ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID2, fixture.userID2,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User2's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.MEMBER); ChatRoomMemberRole.MODERATOR, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.GUEST); ChatRoomMemberRole.MEMBER, roleEventUser1.getNewRole());
// We finally check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser3); roomName, StringUtils.parseName(
roleEventUser3.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user",
fixture.userID2,
roleEventUser3.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match",
ChatRoomMemberRole.MODERATOR, roleEventUser3.getPreviousRole());
assertEquals("Unexpected new role",
ChatRoomMemberRole.MEMBER, roleEventUser3.getNewRole());
} }
/** /**
@ -1815,17 +1838,26 @@ public void testRevokeAdmin()
(ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID2, fixture.userID2,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User2's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.ADMINISTRATOR); ChatRoomMemberRole.ADMINISTRATOR, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.MODERATOR); ChatRoomMemberRole.MODERATOR, roleEventUser1.getNewRole());
// We finally check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser3); roomName, StringUtils.parseName(
roleEventUser3.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user",
fixture.userID2,
roleEventUser3.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match",
ChatRoomMemberRole.ADMINISTRATOR, roleEventUser3.getPreviousRole());
assertEquals("Unexpected new role",
ChatRoomMemberRole.MODERATOR, roleEventUser3.getNewRole());
} }
/** /**
@ -1869,17 +1901,26 @@ public void testRevokeOwnership()
(ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0); (ChatRoomMemberRoleChangeEvent) roomUser3Col.collectedEvents.get(0);
assertEquals("Collected event does not belong to the right chatroom", assertEquals("Collected event does not belong to the right chatroom",
roomName, roleEventUser1.getSourceChatRoom().getName()); roomName, StringUtils.parseName(
roleEventUser1.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user", assertEquals("Collected event does not belong to the expected user",
fixture.userID2, fixture.userID2,
roleEventUser1.getSourceMember().getContactAddress()); roleEventUser1.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match", assertEquals("User2's previous role does not match",
roleEventUser1.getPreviousRole(), ChatRoomMemberRole.OWNER); ChatRoomMemberRole.OWNER, roleEventUser1.getPreviousRole());
assertEquals("Unexpected new role", assertEquals("Unexpected new role",
roleEventUser1.getNewRole(), ChatRoomMemberRole.ADMINISTRATOR); ChatRoomMemberRole.ADMINISTRATOR, roleEventUser1.getNewRole());
// We finally check that event is the same on each side: assertEquals("Collected event does not belong to the right chatroom",
assertEquals(roleEventUser1, roleEventUser3); roomName, StringUtils.parseName(
roleEventUser3.getSourceChatRoom().getName()));
assertEquals("Collected event does not belong to the expected user",
fixture.userID2,
roleEventUser3.getSourceMember().getContactAddress());
assertEquals("User2's previous role does not match",
ChatRoomMemberRole.OWNER, roleEventUser3.getPreviousRole());
assertEquals("Unexpected new role",
ChatRoomMemberRole.ADMINISTRATOR, roleEventUser3.getNewRole());
} }
/** /**

Write Preview
Loading…
Cancel
Save