MultiUserChatIntegrationTest.java

  1. /**
  2.  *
  3.  * Copyright 2015-2024 Florian Schmaus
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.muc;

  19. import static org.junit.jupiter.api.Assertions.assertEquals;
  20. import static org.junit.jupiter.api.Assertions.assertFalse;
  21. import static org.junit.jupiter.api.Assertions.assertNull;
  22. import static org.junit.jupiter.api.Assertions.assertThrows;

  24. import java.util.Set;
  25. import java.util.concurrent.TimeoutException;

  27. import org.jivesoftware.smack.MessageListener;
  28. import org.jivesoftware.smack.SmackException;
  29. import org.jivesoftware.smack.SmackException.NoResponseException;
  30. import org.jivesoftware.smack.SmackException.NotConnectedException;
  31. import org.jivesoftware.smack.XMPPException;
  32. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  33. import org.jivesoftware.smack.packet.Message;
  34. import org.jivesoftware.smack.packet.StanzaError;
  35. import org.jivesoftware.smackx.muc.MultiUserChatException.MissingMucCreationAcknowledgeException;
  36. import org.jivesoftware.smackx.muc.MultiUserChatException.MucAlreadyJoinedException;
  37. import org.jivesoftware.smackx.muc.MultiUserChatException.MucConfigurationNotSupportedException;
  38. import org.jivesoftware.smackx.muc.MultiUserChatException.NotAMucServiceException;

  40. import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
  41. import org.igniterealtime.smack.inttest.TestNotPossibleException;
  42. import org.igniterealtime.smack.inttest.annotations.SmackIntegrationTest;
  43. import org.igniterealtime.smack.inttest.annotations.SpecificationReference;
  44. import org.igniterealtime.smack.inttest.util.SimpleResultSyncPoint;
  45. import org.jxmpp.jid.EntityBareJid;
  46. import org.jxmpp.jid.parts.Resourcepart;
  47. import org.jxmpp.stringprep.XmppStringprepException;

  49. @SpecificationReference(document = "XEP-0045", version = "1.34.6")
  50. public class MultiUserChatIntegrationTest extends AbstractMultiUserChatIntegrationTest {

  52.     public MultiUserChatIntegrationTest(SmackIntegrationTestEnvironment environment)
  53.             throws SmackException.NoResponseException, XMPPException.XMPPErrorException, SmackException.NotConnectedException,
  54.             InterruptedException, TestNotPossibleException, MucAlreadyJoinedException, MissingMucCreationAcknowledgeException, NotAMucServiceException, XmppStringprepException {
  55.         super(environment);
  56.     }

  58.     @SmackIntegrationTest
  59.     public void mucTest() throws Exception {
  60.         EntityBareJid mucAddress = getRandomRoom("smack-inttest-message");

  62.         MultiUserChat mucAsSeenByOne = mucManagerOne.getMultiUserChat(mucAddress);
  63.         MultiUserChat mucAsSeenByTwo = mucManagerTwo.getMultiUserChat(mucAddress);

  65.         final String mucMessage = "Smack Integration Test MUC Test Message " + randomString;
  66.         final SimpleResultSyncPoint resultSyncPoint = new SimpleResultSyncPoint();

  68.         mucAsSeenByTwo.addMessageListener(new MessageListener() {
  69.             @Override
  70.             public void processMessage(Message message) {
  71.                 String body = message.getBody();
  72.                 if (mucMessage.equals(body)) {
  73.                     resultSyncPoint.signal();
  74.                 }
  75.             }
  76.         });

  78.         createMuc(mucAsSeenByOne, "one-" + randomString);
  79.         mucAsSeenByTwo.join(Resourcepart.from("two-" + randomString));
  80.         mucAsSeenByOne.sendMessage(mucMessage);

  82.         try {
  83.             assertResult(resultSyncPoint, "Expected " + conTwo.getUser() + " to receive message that was sent by " + conOne.getUser() + " in room " + mucAddress + " (but it did not).");
  84.         } finally {
  85.             tryDestroy(mucAsSeenByOne);
  86.         }
  87.     }


  90.     /**
  91.      * Asserts that an owner is notified of room destruction when they destroy a room.
  92.      *
  93.      * @throws TimeoutException when roomDestroyed event doesn't get fired
  94.      * @throws Exception when other errors occur
  95.      */
  96.     @SmackIntegrationTest(section = "10.9", quote =
  97.         "A room owner MUST be able to destroy a room, especially if the room is persistent... The room removes all " +
  98.         "users from the room... and destroys the room")
  99.     public void mucDestroyOwnerTest() throws TimeoutException, Exception {

  101.         EntityBareJid mucAddress = getRandomRoom("smack-inttest-destroy-owner");

  103.         MultiUserChat muc = mucManagerOne.getMultiUserChat(mucAddress);
  104.         createMuc(muc, Resourcepart.from("one-" + randomString));

  106.         // These would be a test implementation bug, not assertion failure.
  107.         if (!mucManagerOne.getJoinedRooms().contains(mucAddress)) {
  108.             tryDestroy(muc);
  109.             throw new IllegalStateException("Expected user to have joined a room '" + mucAddress + "' (but does not appear to have done so).");
  110.         }

  112.         final SimpleResultSyncPoint mucDestroyed = new SimpleResultSyncPoint();

  114.         UserStatusListener userStatusListener = new UserStatusListener() {
  115.             @Override
  116.             public void roomDestroyed(MultiUserChat alternateMUC, String password, String reason) {
  117.                 mucDestroyed.signal();
  118.             }
  119.         };

  121.         muc.addUserStatusListener(userStatusListener);

  123.         try {
  124.             muc.destroy("Dummy reason", null);
  125.             assertResult(mucDestroyed, "Expected " + conOne.getUser() + " to be notified of destruction of room " + mucAddress + " (but was not).");
  126.         } finally {
  127.             muc.removeUserStatusListener(userStatusListener);
  128.         }

  130.         Set<EntityBareJid> joinedRooms = mucManagerOne.getJoinedRooms();
  131.         assertFalse(muc.isJoined(), "Expected " + conOne.getUser() + " to no longer be in room " + mucAddress + " after it was destroyed, but it is still in.");
  132.         assertEquals(0, joinedRooms.size(), "Expected " + conOne.getUser() + " to no longer be in any rooms after " + mucAddress + " was destroyed. But it is still in " + joinedRooms);
  133.         assertEquals(0, muc.getOccupantsCount(), "Expected room " + mucAddress + " to no longer have any occupants after it was destroyed (but it has).");
  134.         assertNull(muc.getNickname());
  135.     }

  137.     /**
  138.      * Asserts that an occupant of a room is notified when a room is destroyed.
  139.      *
  140.      * @throws TimeoutException when roomDestroyed event doesn't get fired
  141.      * @throws Exception when other errors occur
  142.      */
  143.     @SmackIntegrationTest(section = "10.9", quote =
  144.         "A room owner MUST be able to destroy a room, especially if the room is persistent... The room removes all " +
  145.             "users from the room... and destroys the room")
  146.     public void mucDestroyTestOccupant() throws TimeoutException, Exception {

  148.         EntityBareJid mucAddress = getRandomRoom("smack-inttest-destroy-occupant");

  150.         MultiUserChat mucAsSeenByOwner = mucManagerOne.getMultiUserChat(mucAddress);
  151.         MultiUserChat mucAsSeenByParticipant = mucManagerTwo.getMultiUserChat(mucAddress);
  152.         createMuc(mucAsSeenByOwner, Resourcepart.from("one-" + randomString));

  154.         // These would be a test implementation bug, not assertion failure.
  155.         mucAsSeenByParticipant.join(Resourcepart.from("two-" + randomString));
  156.         if (!mucManagerTwo.getJoinedRooms().contains(mucAddress)) {
  157.             tryDestroy(mucAsSeenByOwner);
  158.             throw new IllegalStateException("Expected user to have joined a room '" + mucAddress + "' (but does not appear to have done so).");
  159.         }


  162.         final SimpleResultSyncPoint mucDestroyed = new SimpleResultSyncPoint();

  164.         UserStatusListener userStatusListener = new UserStatusListener() {
  165.             @Override
  166.             public void roomDestroyed(MultiUserChat alternateMUC, String password, String reason) {
  167.                 mucDestroyed.signal();
  168.             }
  169.         };

  171.         mucAsSeenByParticipant.addUserStatusListener(userStatusListener);

  173.         try {
  174.             mucAsSeenByOwner.destroy("Dummy reason", null);
  175.             assertResult(mucDestroyed, "Expected " + conTwo.getUser() + " to be notified of destruction of room " + mucAddress + " (but was not).");
  176.         } finally {
  177.             mucAsSeenByParticipant.removeUserStatusListener(userStatusListener);
  178.         }

  180.         Set<EntityBareJid> joinedRooms = mucManagerTwo.getJoinedRooms();
  181.         assertFalse(mucAsSeenByParticipant.isJoined(), "Expected " + conTwo.getUser() + " to no longer be in room " + mucAddress + " after it was destroyed, but it is still in.");
  182.         assertEquals(0, joinedRooms.size(), "Expected " + conTwo.getUser() + " to no longer be in any rooms after " + mucAddress + " was destroyed. But it is still in " + joinedRooms);
  183.         assertEquals(0, mucAsSeenByParticipant.getOccupantsCount(), "Expected room " + mucAddress + " to no longer have any occupants after it was destroyed (but it has).");
  184.         assertNull(mucAsSeenByParticipant.getNickname());
  185.     }

  187.     @SmackIntegrationTest
  188.     public void mucNameChangeTest()
  189.                     throws XmppStringprepException, MucAlreadyJoinedException, MissingMucCreationAcknowledgeException,
  190.                     NotAMucServiceException, NoResponseException, XMPPErrorException, NotConnectedException,
  191.                     InterruptedException, MucConfigurationNotSupportedException {
  192.         EntityBareJid mucAddress = getRandomRoom("smack-inttest-muc-name-change");

  194.         MultiUserChat muc = mucManagerOne.getMultiUserChat(mucAddress);
  195.         createMuc(muc, Resourcepart.from("one-" + randomString));

  197.         final String newRoomName = "New Room Name (" + randomString + ")";

  199.         try {
  200.             muc.getConfigFormManager()
  201.                 .setRoomName(newRoomName)
  202.                 .submitConfigurationForm();

  204.             MultiUserChatManager mucManager = MultiUserChatManager.getInstanceFor(conTwo);
  205.             RoomInfo roomInfo = mucManager.getRoomInfo(muc.getRoom());
  206.             assertEquals(newRoomName, roomInfo.getName());
  207.         } finally {
  208.             tryDestroy(muc);
  209.         }
  210.     }

  212.     @SmackIntegrationTest(section = "8.1", quote = "modify the subject [...] MUST be denied if the <user@host> of the 'from' address of the request does not match "
  213.                     + "the bare JID portion of one of the moderators; in this case, the service MUST return a <forbidden/> error.")
  214.     public void mucTestVisitorNotAllowedToChangeSubject() throws XmppStringprepException, MucAlreadyJoinedException,
  215.                     MissingMucCreationAcknowledgeException, NotAMucServiceException, NoResponseException,
  216.                     XMPPErrorException, NotConnectedException, InterruptedException, TestNotPossibleException {
  217.         final EntityBareJid mucAddress = getRandomRoom("smack-inttest-visitor-change-subject");
  218.         final MultiUserChat mucAsSeenByOne = mucManagerOne.getMultiUserChat(mucAddress);
  219.         final MultiUserChat mucAsSeenByTwo = mucManagerTwo.getMultiUserChat(mucAddress);

  221.         final Resourcepart nicknameOne = Resourcepart.from("one-" + randomString);
  222.         final Resourcepart nicknameTwo = Resourcepart.from("two-" + randomString);

  224.         createMuc(mucAsSeenByOne, nicknameOne);
  225.         try {
  226.             MucConfigFormManager configFormManager = mucAsSeenByOne.getConfigFormManager();
  227.             if (configFormManager.occupantsAreAllowedToChangeSubject()) {
  228.                 configFormManager.disallowOccupantsToChangeSubject().submitConfigurationForm();
  229.             }

  231.             mucAsSeenByTwo.join(nicknameTwo);

  233.             final XMPPException.XMPPErrorException e = assertThrows(XMPPException.XMPPErrorException.class, () -> {
  234.                 mucAsSeenByTwo.changeSubject("Test Subject Change");
  235.             }, "Expected an error after '" + conTwo.getUser()
  236.                             + "' (that is not a moderator) tried to change the subject of room '" + mucAddress
  237.                             + "' (but none occurred).");
  238.             assertEquals(StanzaError.Condition.forbidden, e.getStanzaError().getCondition(),
  239.                             "Unexpected error condition in the (expected) error that was returned to '"
  240.                                             + conTwo.getUser() + "' after it tried to change to subject of room '"
  241.                                             + mucAddress + "' while not being a moderator.");
  242.         } catch (MucConfigurationNotSupportedException e) {
  243.             throw new TestNotPossibleException(e);
  244.         } finally {
  245.             tryDestroy(mucAsSeenByOne);
  246.         }
  247.     }

  249.     @SmackIntegrationTest
  250.     public void mucTestChangeRoomName() throws XmppStringprepException, MucAlreadyJoinedException,
  251.                     MissingMucCreationAcknowledgeException, NotAMucServiceException, NoResponseException,
  252.                     XMPPErrorException, NotConnectedException, InterruptedException, TestNotPossibleException {
  253.         final EntityBareJid mucAddress = getRandomRoom("smack-inttest-change-room-name");
  254.         final MultiUserChat mucAsSeenByOne = mucManagerOne.getMultiUserChat(mucAddress);
  255.         final Resourcepart nicknameOne = Resourcepart.from("one-" + randomString);

  257.         createMuc(mucAsSeenByOne, nicknameOne);
  258.         try {
  259.             String initialRoomName = "Initial Room Name";
  260.             mucAsSeenByOne.getConfigFormManager().setRoomName(initialRoomName).submitConfigurationForm();
  261.             RoomInfo roomInfo = mucManagerOne.getRoomInfo(mucAddress);
  262.             assertEquals(initialRoomName, roomInfo.getName());

  264.             String newRoomName = "New Room Name";
  265.             mucAsSeenByOne.getConfigFormManager().setRoomName(newRoomName).submitConfigurationForm();
  266.             roomInfo = mucManagerOne.getRoomInfo(mucAddress);
  267.             assertEquals(newRoomName, roomInfo.getName());
  268.         } catch (MucConfigurationNotSupportedException e) {
  269.             throw new TestNotPossibleException(e);
  270.         } finally {
  271.             tryDestroy(mucAsSeenByOne);
  272.         }
  273.     }
  274. }
Created with JaCoCo 0.8.6.202009150832