diff --git a/smack-extensions/src/main/java/org/jivesoftware/smackx/jingle/JingleTransportMethodManager.java b/smack-extensions/src/main/java/org/jivesoftware/smackx/jingle/JingleTransportMethodManager.java index 19206384b..98bc100a5 100644 --- a/smack-extensions/src/main/java/org/jivesoftware/smackx/jingle/JingleTransportMethodManager.java +++ b/smack-extensions/src/main/java/org/jivesoftware/smackx/jingle/JingleTransportMethodManager.java @@ -61,6 +61,10 @@ public final class JingleTransportMethodManager extends Manager { transportManagers.put(manager.getNamespace(), manager); } + public void unregisterTransportManager(JingleTransportManager manager) { + transportManagers.remove(manager.getNamespace()); + } + public static JingleTransportManager getTransportManager(XMPPConnection connection, String namespace) { return getInstanceFor(connection).getTransportManager(namespace); } @@ -87,7 +91,7 @@ public final class JingleTransportMethodManager extends Manager { return getTransportManager(transport.getNamespace()); } - public JingleTransportManager getBestAvailableTransportManager(XMPPConnection connection) { + public static JingleTransportManager getBestAvailableTransportManager(XMPPConnection connection) { return getInstanceFor(connection).getBestAvailableTransportManager(); } diff --git a/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/FullJidAndSessionIdTest.java b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/FullJidAndSessionIdTest.java new file mode 100644 index 000000000..ce8060330 --- /dev/null +++ b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/FullJidAndSessionIdTest.java @@ -0,0 +1,47 @@ +/** + * + * Copyright 2017 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.jingle; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertNotSame; +import static junit.framework.TestCase.assertTrue; + +import org.jivesoftware.smack.test.util.SmackTestSuite; + +import org.junit.Test; +import org.jxmpp.jid.FullJid; +import org.jxmpp.jid.impl.JidCreate; +import org.jxmpp.stringprep.XmppStringprepException; + +public class FullJidAndSessionIdTest extends SmackTestSuite { + + @Test + public void equalityTest() throws XmppStringprepException { + FullJid albert = JidCreate.fullFrom("albert@einstein.emc/squared"); + String albertId = "10121922"; + FullJidAndSessionId fns = new FullJidAndSessionId(albert, albertId); + + assertEquals("10121922", fns.getSessionId()); + assertEquals(JidCreate.fullFrom("albert@einstein.emc/squared"), fns.getFullJid()); + + FullJidAndSessionId fns2 = new FullJidAndSessionId(JidCreate.fullFrom("albert@einstein.emc/squared"), "10121922"); + assertTrue(fns.equals(fns2)); + assertEquals(fns.hashCode(), fns2.hashCode()); + + assertNotSame(fns, new FullJidAndSessionId(JidCreate.fullFrom("albert@einstein.emc/squared"), "11111111")); + } +} diff --git a/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleManagerTest.java b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleManagerTest.java new file mode 100644 index 000000000..a277d7f0f --- /dev/null +++ b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleManagerTest.java @@ -0,0 +1,75 @@ +package org.jivesoftware.smackx.jingle; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertNotNull; +import static junit.framework.TestCase.assertNotSame; +import static junit.framework.TestCase.assertNull; + +import org.jivesoftware.smack.DummyConnection; +import org.jivesoftware.smack.XMPPConnection; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.test.util.SmackTestSuite; +import org.jivesoftware.smackx.jingle.element.Jingle; + +import org.junit.Test; +import org.jxmpp.jid.FullJid; +import org.jxmpp.jid.impl.JidCreate; +import org.jxmpp.stringprep.XmppStringprepException; + +/** + * Created by vanitas on 03.07.17. + */ +public class JingleManagerTest extends SmackTestSuite { + + /** + * Might fail in *very* rare cases. + */ + @Test + public void randomTest() { + String r1 = JingleManager.randomId(); + String r2 = JingleManager.randomId(); + + assertNotSame(r1, r2); + assertEquals(24, r1.length()); + } + + @Test + public void threadPoolTest() { + assertNotNull(JingleManager.getThreadPool()); + } + + @Test + public void handlerRegistrationTest() throws XmppStringprepException { + final XMPPConnection connection = new DummyConnection(); + + FullJid remote = JidCreate.fullFrom("test@test.test/test"); + FullJid local = JidCreate.fullFrom("case@case.case/case"); + String sid = JingleManager.randomId(); + JingleSession s = new JingleSession(local, remote, Role.initiator, sid) { + @Override + public XMPPConnection getConnection() { + return connection; + } + + @Override + public void onTransportMethodFailed(String namespace) { + + } + }; + assertNull(JingleManager.getInstanceFor(connection).registerJingleSessionHandler(remote, sid, s)); + assertNotNull(JingleManager.getInstanceFor(connection).registerJingleSessionHandler(remote, sid, s)); + JingleManager.getInstanceFor(connection).unregisterJingleSessionHandler(remote, sid, s); + assertNull(JingleManager.getInstanceFor(connection).registerJingleSessionHandler(remote, sid, s)); + + String stubNamespace = "urn:xmpp:jingle:application:stub:0"; + JingleHandler stub = new JingleHandler() { + @Override + public IQ handleJingleRequest(Jingle jingle) { + return null; + } + }; + + assertNull(JingleManager.getInstanceFor(connection).registerDescriptionHandler(stubNamespace, stub)); + assertNotNull(JingleManager.getInstanceFor(connection).registerDescriptionHandler(stubNamespace, stub)); + } +} diff --git a/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleSessionTest.java b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleSessionTest.java new file mode 100644 index 000000000..ba502728a --- /dev/null +++ b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleSessionTest.java @@ -0,0 +1,215 @@ +/** + * + * Copyright 2017 Paul Schaub + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jivesoftware.smackx.jingle; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertFalse; +import static junit.framework.TestCase.assertNotNull; +import static junit.framework.TestCase.assertNotSame; +import static junit.framework.TestCase.assertNull; + +import java.util.List; + +import org.jivesoftware.smack.DummyConnection; +import org.jivesoftware.smack.XMPPConnection; +import org.jivesoftware.smack.packet.IQ; +import org.jivesoftware.smack.packet.TestIQ; +import org.jivesoftware.smackx.jingle.element.Jingle; +import org.jivesoftware.smackx.jingle.element.JingleAction; +import org.jivesoftware.smackx.jingle.element.JingleContent; +import org.jivesoftware.smackx.jingle.transports.jingle_ibb.JingleIBBTransportSession; + +import org.junit.Test; +import org.jxmpp.jid.FullJid; +import org.jxmpp.jid.impl.JidCreate; +import org.jxmpp.stringprep.XmppStringprepException; + +public class JingleSessionTest { + + private static final XMPPConnection connection = new DummyConnection(); + + private static final IQ sessionInitiateResult = new TestIQ(); + private static final IQ sessionTerminateResult = new TestIQ(); + private static final IQ sessionInfoResult = new TestIQ(); + private static final IQ sessionAcceptResult = new TestIQ(); + + private static final IQ contentAddResult = new TestIQ(); + private static final IQ contentAcceptResult = new TestIQ(); + private static final IQ contentRejectResult = new TestIQ(); + private static final IQ contentModifyResult = new TestIQ(); + private static final IQ contentRemoveResult = new TestIQ(); + + private static final IQ descriptionInfoResult = new TestIQ(); + + private static final IQ securityInfoResult = new TestIQ(); + + private static final IQ transportAcceptResult = new TestIQ(); + private static final IQ transportReplaceResult = new TestIQ(); + private static final IQ transportRejectResult = new TestIQ(); + + @Test + public void jingleSessionTest() throws XmppStringprepException { + FullJid us5 = JidCreate.fullFrom("home@swe.et/home"); + FullJid u2 = JidCreate.fullFrom("place@far.far/away"); + String sessionId = "suchPopMuchWow"; + + JingleSession initiatedSimpleSession = new SimpleSession(us5, u2, Role.initiator, sessionId); + assertEquals(us5, initiatedSimpleSession.getInitiator()); + assertEquals(u2, initiatedSimpleSession.getResponder()); + assertEquals(us5, initiatedSimpleSession.getLocal()); + assertEquals(u2, initiatedSimpleSession.getRemote()); + assertEquals(sessionId, initiatedSimpleSession.getSessionId()); + assertNotNull(initiatedSimpleSession.getContents()); + + String sessionId2 = "popMusicSucks"; + JingleSession respondedSimpleSession = new SimpleSession(u2, us5, Role.responder, sessionId2); + assertEquals(us5, respondedSimpleSession.getLocal()); + assertEquals(us5, respondedSimpleSession.getResponder()); + assertEquals(u2, respondedSimpleSession.getInitiator()); + assertEquals(u2, respondedSimpleSession.getRemote()); + + assertEquals(new FullJidAndSessionId(u2, sessionId), initiatedSimpleSession.getFullJidAndSessionId()); + assertEquals(new FullJidAndSessionId(u2, sessionId2), respondedSimpleSession.getFullJidAndSessionId()); + + assertNull(initiatedSimpleSession.getTransportSession()); + initiatedSimpleSession.setTransportSession(new JingleIBBTransportSession(initiatedSimpleSession)); + assertNotNull(initiatedSimpleSession.getTransportSession()); + + assertNotSame(initiatedSimpleSession, respondedSimpleSession); + assertFalse(initiatedSimpleSession.equals(respondedSimpleSession)); + assertNotSame(initiatedSimpleSession.hashCode(), respondedSimpleSession.hashCode()); + } + + @Test + public void testHandleSessionRequest() { + JingleSession s = new SimpleSession(null, null, null, null); + + assertEquals(sessionAcceptResult, s.handleJingleSessionRequest(simpleAction(JingleAction.session_accept))); + assertEquals(sessionInfoResult, s.handleJingleSessionRequest(simpleAction(JingleAction.session_info))); + assertEquals(sessionInitiateResult, s.handleJingleSessionRequest(simpleAction(JingleAction.session_initiate))); + assertEquals(sessionTerminateResult, s.handleJingleSessionRequest(simpleAction(JingleAction.session_terminate))); + + assertEquals(contentAcceptResult, s.handleJingleSessionRequest(simpleAction(JingleAction.content_accept))); + assertEquals(contentAddResult, s.handleJingleSessionRequest(simpleAction(JingleAction.content_add))); + assertEquals(contentModifyResult, s.handleJingleSessionRequest(simpleAction(JingleAction.content_modify))); + assertEquals(contentRejectResult, s.handleJingleSessionRequest(simpleAction(JingleAction.content_reject))); + assertEquals(contentRemoveResult, s.handleJingleSessionRequest(simpleAction(JingleAction.content_remove))); + + assertEquals(descriptionInfoResult, s.handleJingleSessionRequest(simpleAction(JingleAction.description_info))); + + assertEquals(securityInfoResult, s.handleJingleSessionRequest(simpleAction(JingleAction.security_info))); + + assertEquals(transportAcceptResult, s.handleJingleSessionRequest(simpleAction(JingleAction.transport_accept))); + assertEquals(transportRejectResult, s.handleJingleSessionRequest(simpleAction(JingleAction.transport_reject))); + assertEquals(transportReplaceResult, s.handleJingleSessionRequest(simpleAction(JingleAction.transport_replace))); + } + + private static class SimpleSession extends JingleSession { + + public SimpleSession(FullJid initiator, FullJid responder, Role role, String sid) { + super(initiator, responder, role, sid); + } + + public SimpleSession(FullJid initiator, FullJid responder, Role role, String sid, List contents) { + super(initiator, responder, role, sid, contents); + } + + @Override + public XMPPConnection getConnection() { + return connection; + } + + @Override + public void onTransportMethodFailed(String namespace) { + + } + + @Override + public IQ handleSessionInitiate(Jingle jingle) { + return sessionInitiateResult; + } + + @Override + public IQ handleSessionAccept(Jingle jingle) { + return sessionAcceptResult; + } + + @Override + public IQ handleSessionTerminate(Jingle jingle) { + return sessionTerminateResult; + } + + @Override + public IQ handleSessionInfo(Jingle jingle) { + return sessionInfoResult; + } + + @Override + public IQ handleTransportAccept(Jingle jingle) { + return transportAcceptResult; + } + + @Override + public IQ handleTransportReject(Jingle jingle) { + return transportRejectResult; + } + + @Override + public IQ handleTransportReplace(Jingle jingle) { + return transportReplaceResult; + } + + @Override + public IQ handleContentAdd(Jingle jingle) { + return contentAddResult; + } + + @Override + public IQ handleContentAccept(Jingle jingle) { + return contentAcceptResult; + } + + @Override + public IQ handleContentReject(Jingle jingle) { + return contentRejectResult; + } + + @Override + public IQ handleContentRemove(Jingle jingle) { + return contentRemoveResult; + } + + @Override + public IQ handleContentModify(Jingle jingle) { + return contentModifyResult; + } + + @Override + public IQ handleDescriptionInfo(Jingle jingle) { + return descriptionInfoResult; + } + + @Override + public IQ handleSecurityInfo(Jingle jingle) { + return securityInfoResult; + } + } + + private Jingle simpleAction(JingleAction action) { + return Jingle.getBuilder().setAction(action).setSessionId("test").build(); + } +} diff --git a/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleTransportMethodManagerTest.java b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleTransportMethodManagerTest.java new file mode 100644 index 000000000..a08ed8fa9 --- /dev/null +++ b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleTransportMethodManagerTest.java @@ -0,0 +1,110 @@ +package org.jivesoftware.smackx.jingle; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertNotNull; +import static junit.framework.TestCase.assertNull; + +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +import org.jivesoftware.smack.DummyConnection; +import org.jivesoftware.smack.XMPPConnection; +import org.jivesoftware.smack.test.util.SmackTestSuite; +import org.jivesoftware.smackx.jingle.element.Jingle; +import org.jivesoftware.smackx.jingle.element.JingleAction; +import org.jivesoftware.smackx.jingle.element.JingleContent; +import org.jivesoftware.smackx.jingle.element.JingleContentTransport; +import org.jivesoftware.smackx.jingle.transports.JingleTransportManager; +import org.jivesoftware.smackx.jingle.transports.JingleTransportSession; +import org.jivesoftware.smackx.jingle.transports.jingle_ibb.JingleIBBTransportManager; +import org.jivesoftware.smackx.jingle.transports.jingle_ibb.element.JingleIBBTransport; +import org.jivesoftware.smackx.jingle.transports.jingle_s5b.JingleS5BTransportManager; +import org.jivesoftware.smackx.jingle.transports.jingle_s5b.elements.JingleS5BTransport; + +import org.junit.Test; +import org.jxmpp.jid.impl.JidCreate; +import org.jxmpp.stringprep.XmppStringprepException; + +public class JingleTransportMethodManagerTest extends SmackTestSuite { + + @Test + public void getTransportManagerTest() throws XmppStringprepException { + XMPPConnection connection = new DummyConnection(); + JingleTransportMethodManager jtmm = JingleTransportMethodManager.getInstanceFor(connection); + + assertNull(jtmm.getBestAvailableTransportManager()); + assertNull(jtmm.getTransportManager(JingleIBBTransport.NAMESPACE_V1)); + assertNull(jtmm.getTransportManager(JingleS5BTransport.NAMESPACE_V1)); + + jtmm.registerTransportManager(JingleIBBTransportManager.getInstanceFor(connection)); + assertNull(jtmm.getTransportManager(JingleS5BTransport.NAMESPACE_V1)); + assertNotNull(jtmm.getTransportManager(JingleIBBTransport.NAMESPACE_V1)); + assertEquals(JingleIBBTransportManager.getInstanceFor(connection), jtmm.getBestAvailableTransportManager()); + + jtmm.registerTransportManager(JingleS5BTransportManager.getInstanceFor(connection)); + assertEquals(JingleS5BTransportManager.getInstanceFor(connection), jtmm.getBestAvailableTransportManager()); + + jtmm.unregisterTransportManager(JingleS5BTransportManager.getInstanceFor(connection)); + assertNull(jtmm.getTransportManager(JingleS5BTransport.NAMESPACE_V1)); + jtmm.unregisterTransportManager(JingleIBBTransportManager.getInstanceFor(connection)); + + assertNull(jtmm.getBestAvailableTransportManager()); + + jtmm.registerTransportManager(JingleS5BTransportManager.getInstanceFor(connection)); + assertEquals(JingleS5BTransportManager.getInstanceFor(connection), jtmm.getBestAvailableTransportManager()); + jtmm.registerTransportManager(JingleIBBTransportManager.getInstanceFor(connection)); + assertEquals(JingleS5BTransportManager.getInstanceFor(connection), jtmm.getBestAvailableTransportManager()); + + assertEquals(JingleIBBTransportManager.getInstanceFor(connection), jtmm.getBestAvailableTransportManager( + Collections.singleton(JingleS5BTransport.NAMESPACE_V1))); + + JingleStubTransportManager stub = new JingleStubTransportManager(connection); + jtmm.registerTransportManager(stub); + assertEquals(stub, JingleTransportMethodManager.getTransportManager(connection, JingleStubTransportManager.NAMESPACE)); + assertEquals(JingleS5BTransportManager.getInstanceFor(connection), jtmm.getBestAvailableTransportManager()); + + Jingle jingle = Jingle.getBuilder().setSessionId("test").setAction(JingleAction.session_initiate) + .setInitiator(JidCreate.fullFrom("test@test.test/test")) + .addJingleContent( + JingleContent.getBuilder().setCreator(JingleContent.Creator.initiator).setName("content") + .setSenders(JingleContent.Senders.initiator).setTransport( + new JingleIBBTransport("transportId")).build()).build(); + assertEquals(JingleIBBTransportManager.getInstanceFor(connection), jtmm.getTransportManager(jingle)); + assertEquals(JingleIBBTransportManager.getInstanceFor(connection), + JingleTransportMethodManager.getTransportManager(connection, jingle)); + + Set except = new HashSet<>(); + except.add(JingleIBBTransport.NAMESPACE_V1); + except.add(JingleS5BTransport.NAMESPACE_V1); + assertEquals(stub, jtmm.getBestAvailableTransportManager(except)); + + jtmm.unregisterTransportManager(JingleS5BTransportManager.getInstanceFor(connection)); + jtmm.unregisterTransportManager(JingleIBBTransportManager.getInstanceFor(connection)); + assertEquals(stub, JingleTransportMethodManager.getBestAvailableTransportManager(connection)); + } + + private static class JingleStubTransportManager extends JingleTransportManager { + + public static final String NAMESPACE = "urn:xmpp:jingle:transports:stub:0"; + + public JingleStubTransportManager(XMPPConnection connection) { + super(connection); + } + + @Override + public String getNamespace() { + return NAMESPACE; + } + + @Override + public JingleTransportSession transportSession(JingleSession jingleSession) { + return null; + } + + @Override + public void authenticated(XMPPConnection connection, boolean resumed) { + + } + } +} diff --git a/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleUtilTest.java b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleUtilTest.java index 500ee2279..9863e01a5 100644 --- a/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleUtilTest.java +++ b/smack-extensions/src/test/java/org/jivesoftware/smackx/jingle/JingleUtilTest.java @@ -16,11 +16,15 @@ */ package org.jivesoftware.smackx.jingle; +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertTrue; + import org.jivesoftware.smack.DummyConnection; import org.jivesoftware.smack.XMPPConnection; +import org.jivesoftware.smack.packet.IQ; import org.jivesoftware.smack.test.util.SmackTestSuite; import org.jivesoftware.smackx.jingle.element.Jingle; -import org.jivesoftware.smackx.jingle.element.JingleContent; +import org.jivesoftware.smackx.jingle.element.JingleAction; import org.junit.Before; import org.junit.Test; @@ -36,67 +40,25 @@ public class JingleUtilTest extends SmackTestSuite { private XMPPConnection connection; private JingleUtil jutil; + private FullJid romeo; + private FullJid juliet; + @Before - public void setup() { + public void setup() throws XmppStringprepException { connection = new DummyConnection( DummyConnection.getDummyConfigurationBuilder() .setUsernameAndPassword("romeo@montague.lit", "iluvJulibabe13").build()); jutil = new JingleUtil(connection); + romeo = connection.getUser().asFullJidOrThrow(); + juliet = JidCreate.fullFrom("juliet@capulet.lit/balcony"); } @Test - public void sessionInitiateTest() throws XmppStringprepException { - FullJid romeo = connection.getUser().asFullJidOrThrow(); - FullJid juliet = JidCreate.fullFrom("juliet@capulet.example/yn0cl4bnw0yr3vym"); - - String sid = "851ba2"; - String contentName = "a-file-offer"; - Jingle jingle = jutil.createSessionInitiate(juliet, sid, - JingleContent.Creator.initiator, contentName, JingleContent.Senders.initiator, null, null); - - - - String expected = - "" + - "" + - "" + - "" + - "" + - "1969-07-21T02:56:15Z" + - "This is a test. If this were a real file..." + - "text/plain" + - "test.txt" + - "" + - "6144" + - "w0mcJylzCn+AfvuGdqkty2+KP48=" + - "" + - "" + - " " + - "" + - "" + - "" + - "" + - "" + - ""; + public void createAckTest() { + Jingle jingle = Jingle.getBuilder().setAction(JingleAction.session_initiate).setInitiator(romeo).setSessionId("test").build(); + IQ result = jutil.createAck(jingle); + assertEquals(jingle.getStanzaId(), result.getStanzaId()); + assertTrue(result.getType() == IQ.Type.result); } }