RosterIntegrationTest.java

  1. /**
  2.  *
  3.  * Copyright 2015-2024 Florian Schmaus, 2022-2024 Guus der Kinderen
  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.smack.roster;

  19. import static org.junit.jupiter.api.Assertions.assertEquals;
  20. import static org.junit.jupiter.api.Assertions.assertTrue;

  22. import java.util.Collection;
  23. import java.util.concurrent.TimeoutException;

  25. import org.jivesoftware.smack.StanzaListener;
  26. import org.jivesoftware.smack.filter.AndFilter;
  27. import org.jivesoftware.smack.filter.FromMatchesFilter;
  28. import org.jivesoftware.smack.filter.PresenceTypeFilter;
  29. import org.jivesoftware.smack.filter.StanzaTypeFilter;
  30. import org.jivesoftware.smack.packet.Presence;
  31. import org.jivesoftware.smack.packet.PresenceBuilder;
  32. import org.jivesoftware.smack.roster.packet.RosterPacket.ItemType;
  33. import org.jivesoftware.smack.util.Consumer;
  34. import org.jivesoftware.smack.util.StringUtils;

  36. import org.igniterealtime.smack.inttest.AbstractSmackIntegrationTest;
  37. import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
  38. import org.igniterealtime.smack.inttest.annotations.SmackIntegrationTest;
  39. import org.igniterealtime.smack.inttest.annotations.SpecificationReference;
  40. import org.igniterealtime.smack.inttest.util.IntegrationTestRosterUtil;
  41. import org.igniterealtime.smack.inttest.util.ResultSyncPoint;
  42. import org.igniterealtime.smack.inttest.util.SimpleResultSyncPoint;
  43. import org.jxmpp.jid.BareJid;
  44. import org.jxmpp.jid.Jid;

  46. @SpecificationReference(document = "RFC6121")
  47. public class RosterIntegrationTest extends AbstractSmackIntegrationTest {

  49.     private final Roster rosterOne;
  50.     private final Roster rosterTwo;

  52.     public RosterIntegrationTest(SmackIntegrationTestEnvironment environment) {
  53.         super(environment);
  54.         rosterOne = Roster.getInstanceFor(conOne);
  55.         rosterTwo = Roster.getInstanceFor(conTwo);
  56.     }

  58.     @SmackIntegrationTest
  59.     public void subscribeRequestListenerTest() throws TimeoutException, Exception {
  60.         IntegrationTestRosterUtil.ensureBothAccountsAreNotInEachOthersRoster(conOne, conTwo);

  62.         final SubscribeListener subscribeListener = new SubscribeListener() {
  63.             @Override
  64.             public SubscribeAnswer processSubscribe(Jid from, Presence subscribeRequest) {
  65.                 if (from.equals(conOne.getUser().asBareJid())) {
  66.                     return SubscribeAnswer.Approve;
  67.                 }
  68.                 return SubscribeAnswer.Deny;
  69.             }
  70.         };
  71.         rosterTwo.addSubscribeListener(subscribeListener);

  73.         final String conTwosRosterName = "ConTwo " + testRunId;
  74.         final SimpleResultSyncPoint addedAndSubscribed = new SimpleResultSyncPoint();
  75.         final RosterListener rosterListener = new AbstractRosterListener() {
  76.             @Override
  77.             public void entriesAdded(Collection<Jid> addresses) {
  78.                 checkIfAddedAndSubscribed(addresses);
  79.             }
  80.             @Override
  81.             public void entriesUpdated(Collection<Jid> addresses) {
  82.                 checkIfAddedAndSubscribed(addresses);
  83.             }
  84.             private void checkIfAddedAndSubscribed(Collection<Jid> addresses) {
  85.                 for (Jid jid : addresses) {
  86.                     if (!jid.equals(conTwo.getUser().asBareJid())) {
  87.                         continue;
  88.                     }
  89.                     BareJid bareJid = conTwo.getUser().asBareJid();
  90.                     RosterEntry rosterEntry = rosterOne.getEntry(bareJid);
  91.                     if (rosterEntry == null) {
  92.                         addedAndSubscribed.signalFailure("Added/Updated entry was not for " + bareJid);
  93.                         return;
  94.                     }
  95.                     String name = rosterEntry.getName();
  96.                     if (StringUtils.isNullOrEmpty(name)) {
  97.                         addedAndSubscribed.signalFailure("Added/Updated entry without name");
  98.                         return;
  99.                     }
  100.                     if (!rosterEntry.getName().equals(conTwosRosterName)) {
  101.                         addedAndSubscribed.signalFailure("Added/Updated entry name does not match. Expected: " + conTwosRosterName + " but was: " + rosterEntry.getName());
  102.                         return;
  103.                     }
  104.                     if (!rosterEntry.getType().equals(ItemType.to)) {
  105.                         return;
  106.                     }
  107.                     addedAndSubscribed.signal();
  108.                 }
  109.             }
  110.         };

  112.         rosterOne.addRosterListener(rosterListener);

  114.         try {
  115.             rosterOne.createItemAndRequestSubscription(conTwo.getUser().asBareJid(), conTwosRosterName, null);
  116.             assertResult(addedAndSubscribed,
  117.                 "A roster entry for " + conTwo.getUser().asBareJid() + " using the name '" + conTwosRosterName +
  118.                 "' of type 'to' was expected to be added to the roster of " + conOne.getUser() + " (but it was not).");
  119.         }
  120.         finally {
  121.             rosterTwo.removeSubscribeListener(subscribeListener);
  122.             rosterOne.removeRosterListener(rosterListener);
  123.         }
  124.     }

  126.     /**
  127.      * Asserts that when a user sends out a presence subscription request, the server sends a roster push back to the
  128.      * user.
  129.      *
  130.      * @throws Exception when errors occur
  131.      */
  132.     @SmackIntegrationTest(section = "3.1.2", quote =
  133.         "After locally delivering or remotely routing the presence subscription request, the user's server MUST then " +
  134.         "send a roster push to all of the user's interested resources, containing the potential contact with a " +
  135.         "subscription state of \"none\" and with notation that the subscription is pending (via an 'ask' attribute " +
  136.         "whose value is \"subscribe\").")
  137.     public void testRosterPushAfterSubscriptionRequest() throws Exception {
  138.         IntegrationTestRosterUtil.ensureBothAccountsAreNotInEachOthersRoster(conOne, conTwo);
  139.         rosterTwo.setSubscriptionMode(Roster.SubscriptionMode.manual); // prevents a race condition when asserting the captured roster entry.
  140.         final ResultSyncPoint<RosterEntry, Exception> added = new ResultSyncPoint<>();

  142.         final RosterListener rosterListener = new AbstractRosterListener() {
  143.             @Override
  144.             public void entriesAdded(Collection<Jid> addresses) {
  145.                 for (Jid jid : addresses) {
  146.                     if (!jid.equals(conTwo.getUser().asBareJid())) {
  147.                         continue;
  148.                     }
  149.                     final BareJid bareJid = conTwo.getUser().asBareJid();
  150.                     RosterEntry rosterEntry = rosterOne.getEntry(bareJid);
  151.                     added.signal(rosterEntry);
  152.                     return;
  153.                 }
  154.             }
  155.         };
  156.         rosterOne.addRosterListener(rosterListener);

  158.         final Presence subscribe = conOne.getStanzaFactory().buildPresenceStanza()
  159.                 .ofType(Presence.Type.subscribe)
  160.                 .to(conTwo.getUser().asBareJid())
  161.                 .build();

  163.         try {
  164.             conOne.sendStanza(subscribe);

  166.             final RosterEntry rosterEntry = assertResult(added, "Expected the server to send a roster push back to '" + conOne.getUser() + "' after they sent a presence subscription request to '" + conTwo.getUser().asBareJid() + "' (but the server did not).");
  167.             assertEquals(ItemType.none, rosterEntry.getType(), "Unexpected subscription type on roster push after '" + conOne.getUser() + "' sent a presence subscription request to '" + conTwo.getUser().asBareJid() + "'.");
  168.             assertTrue(rosterEntry.isSubscriptionPending(), "Missing 'ask=subscribe' attribute on roster push after '" + conOne.getUser() + "' sent a presence subscription request to '" + conTwo.getUser().asBareJid() + "'.");
  169.         } finally {
  170.             rosterTwo.setSubscriptionMode(Roster.getDefaultSubscriptionMode());
  171.             rosterOne.removeRosterListener(rosterListener);
  172.         }
  173.     }

  175.     /**
  176.      * Asserts that when a user sends out a presence subscription request to an entity for which the user does not have
  177.      * a pre-existing subscription, the server will deliver the subscription request to that entity.
  178.      *
  179.      * @throws Exception when errors occur
  180.      */
  181.     @SmackIntegrationTest(section = "3.1.3", quote =
  182.         "if there is at least one available resource associated with the contact when the subscription request is " +
  183.         "received by the contact's server, then the contact's server MUST send that subscription request to all " +
  184.         "available resources in accordance with Section 8.")
  185.     public void testPresenceDeliveredToRecipient() throws Exception {
  186.         IntegrationTestRosterUtil.ensureBothAccountsAreNotInEachOthersRoster(conOne, conTwo);

  188.         final ResultSyncPoint<Presence, Exception> added = new ResultSyncPoint<>();
  189.         final StanzaListener stanzaListener = stanza -> added.signal((Presence) stanza);
  190.         conTwo.addAsyncStanzaListener(stanzaListener, new AndFilter(StanzaTypeFilter.PRESENCE, FromMatchesFilter.createBare(conOne.getUser())));

  192.         final Presence subscribe = conOne.getStanzaFactory().buildPresenceStanza()
  193.                 .ofType(Presence.Type.subscribe)
  194.                 .to(conTwo.getUser().asBareJid())
  195.                 .build();

  197.         try {
  198.             conOne.sendStanza(subscribe);
  199.             final Presence received = assertResult(added, "Expected subscription request from '" + conOne.getUser() + "' to '" + conTwo.getUser().asBareJid() + "' to be delivered to " + conTwo.getUser() + " (but it did not).");
  200.             assertEquals(Presence.Type.subscribe, received.getType(), "Unexpected presence type in presence stanza received by '" + conTwo.getUser() + "' after '" + conOne.getUser() + "' sent a presence subscription request.");
  201.         } finally {
  202.             conTwo.removeAsyncStanzaListener(stanzaListener);
  203.         }
  204.     }

  206.     /**
  207.      * Asserts that when a user sends a presence subscription approval, the server stamps the bare JID of the sender,
  208.      * and delivers it to the requester.
  209.      *
  210.      * @throws Exception when errors occur
  211.      */
  212.     @SmackIntegrationTest(section = "3.1.5", quote =
  213.         "When the contact's client sends the subscription approval, the contact's server MUST stamp the outbound " +
  214.         "stanza with the bare JID <contact@domainpart> of the contact and locally deliver or remotely route the " +
  215.         "stanza to the user.")
  216.     public void testPresenceApprovalStampedAndDelivered() throws Exception {
  217.         IntegrationTestRosterUtil.ensureBothAccountsAreNotInEachOthersRoster(conOne, conTwo);

  219.         rosterTwo.setSubscriptionMode(Roster.SubscriptionMode.accept_all);

  221.         // Modify the outbound 'subscribed' stanza, to be 'wrong' (addressed to a full rather than a bare JID), to test if the server overrides this.
  222.         final Consumer<PresenceBuilder> interceptor = (PresenceBuilder presenceBuilder) -> presenceBuilder.to(conOne.getUser()).build();
  223.         conTwo.addPresenceInterceptor(interceptor, p -> p.getType() == Presence.Type.subscribed);

  225.         final ResultSyncPoint<Presence, Exception> added = new ResultSyncPoint<>();
  226.         final StanzaListener stanzaListener = stanza -> added.signal((Presence) stanza);

  228.         conOne.addAsyncStanzaListener(stanzaListener, PresenceTypeFilter.SUBSCRIBED);

  230.         final Presence subscribe = conOne.getStanzaFactory().buildPresenceStanza()
  231.                 .ofType(Presence.Type.subscribe)
  232.                 .to(conTwo.getUser().asBareJid())
  233.                 .build();

  235.         try {
  236.             conOne.sendStanza(subscribe);

  238.             final Presence received = assertResult(added, "Expected presence 'subscribed' stanza to be delivered to '" + conOne.getUser() + "' after '" + conTwo.getUser() + "' approved their subscription request (but it was not).");
  239.             assertEquals(conTwo.getUser().asBareJid(), received.getFrom().asEntityBareJidOrThrow(), "Expected presence 'subscribed' stanza that was delivered to '" + conOne.getUser() + "' after '" + conTwo.getUser() + "' approved their subscription request to have a 'from' attribute value that is associated to '" + conTwo.getUser().getLocalpart() + "' (but it did not).");
  240.             assertTrue(received.getFrom().isEntityBareJid(), "Expected presence 'subscribed' stanza that was delivered to '" + conOne.getUser() + "' after '" + conTwo.getUser() + "' approved their subscription request to have a 'from' attribute value that is a bare JID (but it was not).");
  241.         } finally {
  242.             rosterTwo.setSubscriptionMode(Roster.getDefaultSubscriptionMode());
  243.             conTwo.removePresenceInterceptor(interceptor);
  244.             conOne.removeAsyncStanzaListener(stanzaListener);
  245.         }
  246.     }

  248.     /**
  249.      * Asserts that when a user sends a presence subscription approval, the server sends a roster push to the user with
  250.      * a subscription 'from'.
  251.      *
  252.      * @throws Exception when errors occur
  253.      */
  254.     @SmackIntegrationTest(section = "3.1.5", quote =
  255.         "The contact's server then MUST send an updated roster push to all of the contact's interested resources, " +
  256.         "with the 'subscription' attribute set to a value of \"from\".")
  257.     public void testPresenceApprovalYieldsRosterPush() throws Exception {
  258.         IntegrationTestRosterUtil.ensureBothAccountsAreNotInEachOthersRoster(conOne, conTwo);

  260.         rosterTwo.setSubscriptionMode(Roster.SubscriptionMode.accept_all);

  262.         final ResultSyncPoint<RosterEntry, Exception> updated = new ResultSyncPoint<>();

  264.         final RosterListener rosterListener = new AbstractRosterListener() {
  265.             @Override
  266.             public void entriesAdded(Collection<Jid> addresses) {
  267.                 for (Jid jid : addresses) {
  268.                     if (!jid.equals(conOne.getUser().asBareJid())) {
  269.                         continue;
  270.                     }
  271.                     BareJid bareJid = conOne.getUser().asBareJid();
  272.                     RosterEntry rosterEntry = rosterTwo.getEntry(bareJid);
  273.                     updated.signal(rosterEntry);
  274.                 }
  275.             }
  276.         };
  277.         rosterTwo.addRosterListener(rosterListener);

  279.         final Presence subscribe = conOne.getStanzaFactory().buildPresenceStanza()
  280.                 .ofType(Presence.Type.subscribe)
  281.                 .to(conTwo.getUser().asBareJid())
  282.                 .build();

  284.         try {
  285.             conOne.sendStanza(subscribe);
  286.             // The 'subscribe' gets automatically approved by conTwo.

  288.             final RosterEntry entry = assertResult(updated, "Expected '" + conTwo.getUser() + "' to receive a roster push with an update for the entry of '" + conOne.getUser().asBareJid() + "' after '" + conTwo.getUser() + "' approved their subscription request.");
  289.             assertEquals(ItemType.from, entry.getType(), "Unexpected type for '" + conOne.getUser().asBareJid() + "''s entry in '" + conTwo.getUser().asBareJid() + "''s roster.");
  290.         } finally {
  291.             rosterTwo.setSubscriptionMode(Roster.getDefaultSubscriptionMode());
  292.             rosterTwo.removeRosterListener(rosterListener);
  293.         }
  294.     }

  296.     /**
  297.      * Asserts that when a user sends a presence subscription approval, the server sends a roster push to the user with
  298.      * a subscription 'both' when the contact already has a subscription to the other entity.
  299.      *
  300.      * @throws Exception when errors occur
  301.      */
  302.     @SmackIntegrationTest(section = "3.1.5", quote =
  303.         "The contact's server then MUST send an updated roster push to all of the contact's interested resources, " +
  304.         "with the 'subscription' attribute set to a value of \"from\". (Here we assume that the contact does not " +
  305.         "already have a subscription to the user; if that were the case, the 'subscription' attribute would be set " +
  306.         "to a value of \"both\", as explained under Appendix A.)")
  307.     public void testPresenceApprovalYieldsRosterPush2() throws Exception {
  308.         IntegrationTestRosterUtil.ensureBothAccountsAreNotInEachOthersRoster(conOne, conTwo);

  310.         // Setup fixture: establish one-way subscription.
  311.         rosterOne.setSubscriptionMode(Roster.SubscriptionMode.accept_all);

  313.         final SimpleResultSyncPoint fixtureComplete = new SimpleResultSyncPoint();
  314.         RosterListener rosterListenerTwo = new AbstractRosterListener() {
  315.             @Override
  316.             public void entriesAdded(Collection<Jid> addresses) {
  317.                 checkIfAdded(addresses);
  318.             }
  319.             @Override
  320.             public void entriesUpdated(Collection<Jid> addresses) {
  321.                 checkIfAdded(addresses);
  322.             }
  323.             private void checkIfAdded(Collection<Jid> addresses) {
  324.                 for (Jid jid : addresses) {
  325.                     final BareJid bareJid = conOne.getUser().asBareJid();
  326.                     if (!jid.equals(bareJid)) {
  327.                         continue;
  328.                     }
  329.                     if (rosterTwo.getEntry(bareJid) == null) {
  330.                         continue;
  331.                     }
  332.                     if (rosterTwo.getEntry(bareJid).getType() == ItemType.none) {
  333.                         continue;
  334.                     }
  335.                     fixtureComplete.signal();
  336.                     rosterTwo.removeRosterListener(this);
  337.                 }
  338.             }
  339.         };
  340.         rosterTwo.addRosterListener(rosterListenerTwo);

  342.         final Presence subscribeOne = conTwo.getStanzaFactory().buildPresenceStanza()
  343.                 .ofType(Presence.Type.subscribe)
  344.                 .to(conOne.getUser().asBareJid())
  345.                 .build();
  346.         try {
  347.             conTwo.sendStanza(subscribeOne);

  349.             fixtureComplete.waitForResult(connection.getReplyTimeout());
  350.         } finally {
  351.             rosterOne.setSubscriptionMode(Roster.getDefaultSubscriptionMode());
  352.             rosterTwo.removeRosterListener(rosterListenerTwo);
  353.         }

  355.         // Setup fixture is now complete. Execute the test.
  356.         rosterTwo.setSubscriptionMode(Roster.SubscriptionMode.accept_all);

  358.         final ResultSyncPoint<RosterEntry, Exception> updated = new ResultSyncPoint<>();

  360.         rosterListenerTwo = new AbstractRosterListener() {
  361.             @Override
  362.             public void entriesUpdated(Collection<Jid> addresses) {
  363.                 for (Jid jid : addresses) {
  364.                     if (!jid.equals(conOne.getUser().asBareJid())) {
  365.                         continue;
  366.                     }
  367.                     BareJid bareJid = conOne.getUser().asBareJid();
  368.                     updated.signal(rosterTwo.getEntry(bareJid));
  369.                 }
  370.             }
  371.         };
  372.         rosterTwo.addRosterListener(rosterListenerTwo);

  374.         final Presence subscribeTwo = conOne.getStanzaFactory().buildPresenceStanza()
  375.                 .ofType(Presence.Type.subscribe)
  376.                 .to(conTwo.getUser().asBareJid())
  377.                 .build();

  379.         try {
  380.             conOne.sendStanza(subscribeTwo);

  382.             final RosterEntry entry = assertResult(updated, "Expected '" + conTwo.getUser() + "' to receive a roster push with an update for the entry of '" + conOne.getUser().asBareJid() + "' after '" + conOne.getUser() + "' approved their subscription request.");
  383.             assertEquals(ItemType.both, entry.getType(), "Unexpected type for '" + conOne.getUser().asBareJid() + "''s entry in '" + conTwo.getUser().asBareJid() + "''s roster.");
  384.         } finally {
  385.             rosterTwo.setSubscriptionMode(Roster.getDefaultSubscriptionMode());
  386.             rosterTwo.removeRosterListener(rosterListenerTwo);
  387.         }
  388.     }

  390.     /**
  391.      * Asserts that when a presence subscription request is approved, the server sends the latest presence of the now
  392.      * subscribed entity to the subscriber.
  393.      *
  394.      * @throws Exception when errors occur
  395.      */
  396.     @SmackIntegrationTest(section = "3.1.5", quote =
  397.         "The contact's server MUST then also send current presence to the user from each of the contact's available resources.")
  398.     public void testCurrentPresenceSentAfterSubscriptionApproval() throws Exception {
  399.         IntegrationTestRosterUtil.ensureBothAccountsAreNotInEachOthersRoster(conOne, conTwo);

  401.         final String needle = "Look for me!";
  402.         conTwo.sendStanza(conTwo.getStanzaFactory().buildPresenceStanza().setStatus(needle).build());

  404.         rosterTwo.setSubscriptionMode(Roster.SubscriptionMode.accept_all);

  406.         final SimpleResultSyncPoint received = new SimpleResultSyncPoint();
  407.         final StanzaListener stanzaListener = stanza -> {
  408.             final Presence presence = (Presence) stanza;

  410.             String status = presence.getStatus();
  411.             if (status == null) return;

  413.             if (status.equals(needle)) {
  414.                 received.signal();
  415.             }
  416.         };
  417.         conOne.addAsyncStanzaListener(stanzaListener, new AndFilter(StanzaTypeFilter.PRESENCE, FromMatchesFilter.createBare(conTwo.getUser())));

  419.         final Presence subscribe = conOne.getStanzaFactory().buildPresenceStanza()
  420.                 .ofType(Presence.Type.subscribe)
  421.                 .to(conTwo.getUser().asBareJid())
  422.                 .build();

  424.         try {
  425.             conOne.sendStanza(subscribe);

  427.             assertResult(received, "Expected '" + conTwo.getUser() + "' to receive '" + conOne.getUser() + "''s current presence update (including the status '" + needle + "'), but it did not.");
  428.         } finally {
  429.             rosterTwo.setSubscriptionMode(Roster.getDefaultSubscriptionMode());
  430.             conOne.removeAsyncStanzaListener(stanzaListener);
  431.         }
  432.     }

  434. }
Created with JaCoCo 0.8.6.202009150832