MultiUserChatEntityIntegrationTest.java

  1. /**
  2.  *
  3.  * Copyright 2021 Dan Caseley
  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.  */

  18. package org.jivesoftware.smackx.muc;

  20. import static org.junit.jupiter.api.Assertions.assertEquals;
  21. import static org.junit.jupiter.api.Assertions.assertFalse;
  22. import static org.junit.jupiter.api.Assertions.assertThrows;
  23. import static org.junit.jupiter.api.Assertions.assertTrue;

  25. import java.util.List;
  26. import java.util.Map;

  28. import org.jivesoftware.smack.SmackException;
  29. import org.jivesoftware.smack.XMPPException;
  30. import org.jivesoftware.smack.packet.StanzaError;
  31. import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
  32. import org.jivesoftware.smackx.disco.packet.DiscoverInfo;
  33. import org.jivesoftware.smackx.disco.packet.DiscoverItems;
  34. import org.jivesoftware.smackx.muc.MultiUserChatException.MissingMucCreationAcknowledgeException;
  35. import org.jivesoftware.smackx.muc.MultiUserChatException.MucAlreadyJoinedException;
  36. import org.jivesoftware.smackx.muc.MultiUserChatException.NotAMucServiceException;
  37. import org.jivesoftware.smackx.muc.packet.MUCInitialPresence;

  39. import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
  40. import org.igniterealtime.smack.inttest.TestNotPossibleException;
  41. import org.igniterealtime.smack.inttest.annotations.SmackIntegrationTest;
  42. import org.igniterealtime.smack.inttest.annotations.SpecificationReference;

  44. import org.jxmpp.jid.DomainBareJid;
  45. import org.jxmpp.jid.EntityBareJid;
  46. import org.jxmpp.jid.EntityFullJid;
  47. import org.jxmpp.jid.parts.Resourcepart;
  48. import org.jxmpp.stringprep.XmppStringprepException;

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

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

  59.     /**
  60.      * Asserts that a MUC service can be discovered.
  61.      *
  62.      * @throws Exception when errors occur
  63.      */
  64.     @SmackIntegrationTest(section = "6.1", quote =
  65.         "An entity often discovers a MUC service by sending a Service Discovery items (\"disco#items\") request to " +
  66.         "its own server. The server then returns the services that are associated with it.")
  67.     public void mucTestForDiscoveringMuc() throws Exception {
  68.         // This repeats some logic from the `AbstractMultiUserChatIntegrationTest` constructor, but is preserved here
  69.         // as an explicit test, because that might not always be true.
  70.         List<DomainBareJid> services = ServiceDiscoveryManager.getInstanceFor(conOne).findServices(MUCInitialPresence.NAMESPACE, true, false);
  71.         assertFalse(services.isEmpty(), "Expected to be able to find MUC services on the domain that '" + conOne.getUser() + "' is connecting to (but could not).");
  72.     }

  74.     /**
  75.      * Asserts that a MUC service can have its features discovered.
  76.      *
  77.      * @throws Exception when errors occur
  78.      */
  79.     @SmackIntegrationTest(section = "6.2", quote =
  80.         "An entity may wish to discover if a service implements the Multi-User Chat protocol; in order to do so, it " +
  81.             "sends a service discovery information (\"disco#info\") query to the MUC service's JID. The service MUST " +
  82.             "return its identity and the features it supports.")
  83.     public void mucTestForDiscoveringFeatures() throws Exception {
  84.         DiscoverInfo info = ServiceDiscoveryManager.getInstanceFor(conOne).discoverInfo(mucService);
  85.         assertFalse(info.getIdentities().isEmpty(), "Expected the service discovery information for service " + mucService + " to include identities (but it did not).");
  86.         assertFalse(info.getFeatures().isEmpty(), "Expected the service discovery information for service " + mucService + " to include features (but it did not).");
  87.     }

  89.     /**
  90.      * Asserts that a MUC Service lists its public rooms.
  91.      *
  92.      * @throws Exception when errors occur
  93.      */
  94.     @SmackIntegrationTest(section = "6.3", quote =
  95.         "The service discovery items (\"disco#items\") protocol enables an entity to query a service for a list of " +
  96.         "associated items, which in the case of a chat service would consist of the specific chat rooms hosted by the" +
  97.         "service. The service SHOULD return a full list of the public rooms it hosts (i.e., not return any rooms that" +
  98.         "are hidden).")
  99.     public void mucTestForDiscoveringRooms() throws Exception {
  100.         EntityBareJid mucAddressPublic = getRandomRoom("smack-inttest-publicroom");
  101.         MultiUserChat mucAsSeenByOne = mucManagerOne.getMultiUserChat(mucAddressPublic);

  103.         EntityBareJid mucAddressHidden = getRandomRoom("smack-inttest-hiddenroom");
  104.         MultiUserChat mucAsSeenByTwo = mucManagerTwo.getMultiUserChat(mucAddressHidden);

  106.         createMuc(mucAsSeenByOne, Resourcepart.from("one-" + randomString));

  108.         Map<EntityBareJid, HostedRoom> rooms;
  109.         try {
  110.             createHiddenMuc(mucAsSeenByTwo, Resourcepart.from("two-" + randomString));
  111.             rooms = mucManagerThree.getRoomsHostedBy(mucService);
  112.         } finally {
  113.             tryDestroy(mucAsSeenByOne);
  114.             tryDestroy(mucAsSeenByTwo);
  115.         }

  117.         assertTrue(rooms.containsKey(mucAddressPublic), "Expected the disco response from " + mucService + " to include the public room " + mucAddressPublic + " (but it did not).");
  118.         assertFalse(rooms.containsKey(mucAddressHidden), "Expected the disco response from " + mucService + " to not include the hidden room " + mucAddressHidden + " (but it did).");
  119.     }

  121.     /**
  122.      * Asserts that a MUC Service returns disco info for a room.
  123.      *
  124.      * @throws Exception when errors occur
  125.      */
  126.     @SmackIntegrationTest(section = "6.4", quote =
  127.         "Using the disco#info protocol, an entity may also query a specific chat room for more detailed information " +
  128.         "about the room....The room MUST return its identity and SHOULD return the features it supports")
  129.     public void mucTestForDiscoveringRoomInfo() throws Exception {
  130.         EntityBareJid mucAddress = getRandomRoom("smack-inttest-discoinfo");
  131.         MultiUserChat mucAsSeenByOne = mucManagerOne.getMultiUserChat(mucAddress);
  132.         createMuc(mucAsSeenByOne, Resourcepart.from("one-" + randomString));

  134.         DiscoverInfo discoInfo;
  135.         try {
  136.             // Use SDM because mucManagerOne.getRoomInfo(mucAddress) might not use Disco
  137.             discoInfo = ServiceDiscoveryManager.getInstanceFor(conOne).discoverInfo(mucAddress);
  138.         } finally {
  139.             tryDestroy(mucAsSeenByOne);
  140.         }

  142.         assertFalse(discoInfo.getIdentities().isEmpty(), "Expected the service discovery information for room " + mucAddress + " to include identities (but it did not).");
  143.         assertFalse(discoInfo.getFeatures().isEmpty(), "Expected the service discovery information for room " + mucAddress + " to include features (but it did not).");
  144.         assertTrue(discoInfo.getFeatures().stream().anyMatch(feature -> MultiUserChatConstants.NAMESPACE.equals(feature.getVar())), "Expected the service discovery information for room " + mucAddress + " to include the '" + MultiUserChatConstants.NAMESPACE + "' feature (but it did not).");
  145.     }

  147.     /**
  148.      * Asserts that a MUC Service returns disco info for a room's items.
  149.      *
  150.      * @throws Exception when errors occur
  151.      */
  152.     @SmackIntegrationTest(section = "6.5", quote =
  153.         "An entity MAY also query a specific chat room for its associated items. An implementation MAY return a list " +
  154.         "of existing occupants if that information is publicly available, or return no list at all if this " +
  155.         "information is kept private.")
  156.     public void mucTestForDiscoveringRoomItems() throws Exception {
  157.         EntityBareJid mucAddress = getRandomRoom("smack-inttest-discoitems");
  158.         MultiUserChat mucAsSeenByOne = mucManagerOne.getMultiUserChat(mucAddress);
  159.         createMuc(mucAsSeenByOne, Resourcepart.from("one-" + randomString));

  161.         DiscoverItems roomItems;
  162.         try {
  163.             roomItems = ServiceDiscoveryManager.getInstanceFor(conTwo).discoverItems(mucAddress);
  164.         } finally {
  165.             tryDestroy(mucAsSeenByOne);
  166.         }

  168.         assertEquals(1, roomItems.getItems().size(), "Unexpected amount of disco items for " + mucAddress);
  169.     }

  171.     /**
  172.      * Asserts that a non-occupant receives a Bad Request error when attempting to query an occupant by their
  173.      * occupant JID.
  174.      *
  175.      * @throws Exception when errors occur
  176.      */
  177.     @SmackIntegrationTest(section = "6.6", quote =
  178.         "If a non-occupant attempts to send a disco request to an address of the form <room@service/nick>, a MUC " +
  179.         "service MUST return a <bad-request> error")
  180.     public void mucTestForRejectingDiscoOnRoomOccupantByNonOccupant() throws Exception {
  181.         EntityBareJid mucAddress = getRandomRoom("smack-inttest-discoitems");
  182.         MultiUserChat mucAsSeenByOne = mucManagerOne.getMultiUserChat(mucAddress);
  183.         final Resourcepart nicknameOne = Resourcepart.from("one-" + randomString);
  184.         createMuc(mucAsSeenByOne, nicknameOne);
  185.         final EntityFullJid mucAsSeenByOneUserJid = mucAsSeenByOne.getMyRoomJid();
  186.         // Ensure that we do not invoke discoverItems() with null below. This should not happen, as the room JID should
  187.         // be non-null after we created and joined the room. But it can not hurt to explicitly test for it either.
  188.         if (mucAsSeenByOneUserJid == null) {
  189.             throw new AssertionError();
  190.         }

  192.         XMPPException.XMPPErrorException xe;
  193.         try {
  194.             xe = assertThrows(XMPPException.XMPPErrorException.class,
  195.                             () -> ServiceDiscoveryManager.getInstanceFor(conTwo).discoverItems(mucAsSeenByOneUserJid),
  196.                     "Expected an XMPP error when " + conTwo.getUser() + " was trying to discover items of " + mucAsSeenByOneUserJid);
  197.         } finally {
  198.             tryDestroy(mucAsSeenByOne);
  199.         }

  201.         final StanzaError.Condition expectedCondition;
  202.         switch (sinttestConfiguration.compatibilityMode) {
  203.         default:
  204.             expectedCondition = StanzaError.Condition.bad_request;
  205.             break;
  206.         case ejabberd:
  207.             expectedCondition = StanzaError.Condition.not_acceptable;
  208.             break;
  209.         }
  210.         assertEquals(expectedCondition, xe.getStanzaError().getCondition(),
  211.             "Unexpected error condition in error returned when " + conTwo.getUser() + " was trying to discover items of " + mucAsSeenByOneUserJid);
  212.     }
  213. }
Created with JaCoCo 0.8.6.202009150832