Add Integration Test Framework

and resurrect a few integration tests.

smack-integration-test/src/main/java/org/jivesoftware/smack/LoginIntegrationTest.java

@@ -0,0 +1,71 @@
+/**
+ *
+ * Copyright 2015 Florian Schmaus
+ *
+ * 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.smack;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+
+import org.igniterealtime.smack.inttest.AbstractSmackLowLevelIntegrationTest;
+import org.igniterealtime.smack.inttest.Configuration;
+import org.igniterealtime.smack.inttest.SmackIntegrationTest;
+import org.jivesoftware.smack.sasl.SASLError;
+import org.jivesoftware.smack.sasl.SASLErrorException;
+import org.jivesoftware.smack.tcp.XMPPTCPConnection;
+import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
+import org.jivesoftware.smack.util.StringUtils;
+
+public class LoginIntegrationTest extends AbstractSmackLowLevelIntegrationTest {
+
+    public LoginIntegrationTest(Configuration configuration, String testRunId) {
+        super(configuration, testRunId);
+    }
+
+    /**
+     * Check that the server is returning the correct error when trying to login using an invalid
+     * (i.e. non-existent) user.
+     *
+     * @throws InterruptedException 
+     * @throws XMPPException 
+     * @throws IOException 
+     * @throws SmackException 
+     * @throws NoSuchAlgorithmException 
+     * @throws KeyManagementException 
+     */
+    @SmackIntegrationTest
+    public void testInvalidLogin() throws SmackException, IOException, XMPPException,
+                    InterruptedException, KeyManagementException, NoSuchAlgorithmException {
+        final String nonExistentUserString = StringUtils.randomString(24);
+        XMPPTCPConnectionConfiguration conf = getConnectionConfiguration().setUsernameAndPassword(
+                        nonExistentUserString, "invalidPassword").build();
+
+        XMPPTCPConnection connection = new XMPPTCPConnection(conf);
+        connection.connect();
+
+        try {
+            connection.login();
+            fail("Exception expected");
+        }
+        catch (SASLErrorException e) {
+            assertEquals(SASLError.not_authorized, e.getSASLFailure().getSASLError());
+        }
+    }
+
+}

smack-integration-test/src/main/java/org/jivesoftware/smack/StreamManagementTest.java

@@ -0,0 +1,82 @@
+/**
+ *
+ * Copyright 2015 Florian Schmaus
+ *
+ * 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.smack;
+
+import java.io.IOException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+
+import org.igniterealtime.smack.inttest.AbstractSmackLowLevelIntegrationTest;
+import org.igniterealtime.smack.inttest.Configuration;
+import org.igniterealtime.smack.inttest.SmackIntegrationTest;
+import org.igniterealtime.smack.inttest.TestNotPossibleException;
+import org.jivesoftware.smack.SmackException.NotConnectedException;
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.tcp.XMPPTCPConnection;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+public class StreamManagementTest extends AbstractSmackLowLevelIntegrationTest {
+
+    public StreamManagementTest(Configuration configuration, String testRunId)
+                    throws Exception {
+        super(configuration, testRunId);
+        performCheck(new ConnectionCallback() {
+            @Override
+            public void connectionCallback(XMPPTCPConnection connection) throws Exception {
+                if (!connection.isSmAvailable()) {
+                    throw new TestNotPossibleException("XEP-198: Stream Mangement not supported by service");
+                }
+            }
+        });
+    }
+
+    @BeforeClass
+    public static void before() {
+        // TODO remove this once stream mangement is enabled per default
+        XMPPTCPConnection.setUseStreamManagementDefault(true);
+    }
+
+    @AfterClass
+    public static void after() {
+        XMPPTCPConnection.setUseStreamManagementDefault(false);
+    }
+
+    @SmackIntegrationTest
+    public void testStreamManagement(XMPPTCPConnection conOne, XMPPTCPConnection conTwo) throws InterruptedException, KeyManagementException,
+                    NoSuchAlgorithmException, SmackException, IOException, XMPPException,
+                    TestNotPossibleException {
+        send("Hi, what's up?", conOne, conTwo);
+
+        conOne.instantShutdown();
+
+        send("Hi, what's up? I've been just instantly shutdown", conOne, conTwo);
+
+        // Reconnect with xep198
+        conOne.connect();
+
+        send("Hi, what's up? I've been just resumed", conOne, conTwo);
+        // TODO check that all messages where received
+    }
+
+    private static void send(String messageString, XMPPConnection from, XMPPConnection to)
+                    throws NotConnectedException, InterruptedException {
+        Message message = new Message(to.getUser());
+        message.setBody(messageString);
+        from.sendStanza(message);
+    }
+}

smack-integration-test/src/main/java/org/jivesoftware/smackx/filetransfer/FileTransferIntegrationTest.java

@@ -0,0 +1,112 @@
+/**
+ *
+ * Copyright 2015 Florian Schmaus
+ *
+ * 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.filetransfer;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+
+import org.igniterealtime.smack.inttest.AbstractSmackIntegrationTest;
+import org.igniterealtime.smack.inttest.SmackIntegrationTest;
+import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
+import org.igniterealtime.smack.inttest.util.ResultSyncPoint;
+import org.jivesoftware.smack.SmackException;
+import org.jivesoftware.smack.XMPPException.XMPPErrorException;
+import org.jivesoftware.smack.util.StringUtils;
+
+public class FileTransferIntegrationTest extends AbstractSmackIntegrationTest {
+
+    private static final int MAX_FT_DURATION = 360;
+
+    private final FileTransferManager ftManagerOne;
+    private final FileTransferManager ftManagerTwo;
+
+    public FileTransferIntegrationTest(SmackIntegrationTestEnvironment environment) {
+        super(environment);
+        ftManagerOne = FileTransferManager.getInstanceFor(conOne);
+        ftManagerTwo = FileTransferManager.getInstanceFor(conTwo);
+    }
+
+    private static final byte[] dataToSend = StringUtils.randomString(1024 * 4 * 5).getBytes();
+
+    @SmackIntegrationTest
+    public void fileTransferTest() throws Exception {
+        genericfileTransferTest();
+    }
+
+    @SmackIntegrationTest
+    public void ibbFileTransferTest() throws Exception {
+        FileTransferNegotiator.IBB_ONLY = true;
+        genericfileTransferTest();
+        FileTransferNegotiator.IBB_ONLY = false;
+    }
+
+    private void genericfileTransferTest() throws Exception {
+        final ResultSyncPoint<String, Exception> resultSyncPoint = new ResultSyncPoint<>();
+        final FileTransferListener receiveListener = new FileTransferListener() {
+            @Override
+            public void fileTransferRequest(FileTransferRequest request) {
+                byte[] dataReceived = null;
+                IncomingFileTransfer ift = request.accept();
+                try {
+                    InputStream is = ift.recieveFile();
+                    ByteArrayOutputStream os = new ByteArrayOutputStream();
+                    int nRead;
+                    byte[] buf = new byte[1024];
+                    while ((nRead = is.read(buf, 0, buf.length)) != -1) {
+                        os.write(buf, 0, nRead);
+                    }
+                    os.flush();
+                    dataReceived = os.toByteArray();
+                    if (Arrays.equals(dataToSend, dataReceived)) {
+                        resultSyncPoint.signal("Received data matches send data. \\o/");
+                    }
+                    else {
+                        resultSyncPoint.signal(new Exception("Received data does not match"));
+                    }
+                }
+                catch (SmackException | IOException | XMPPErrorException | InterruptedException e) {
+                    resultSyncPoint.signal(e);
+                }
+            }
+        };
+        ftManagerTwo.addFileTransferListener(receiveListener);
+
+        OutgoingFileTransfer oft = ftManagerOne.createOutgoingFileTransfer(conTwo.getUser());
+        oft.sendStream(new ByteArrayInputStream(dataToSend), "hello.txt", dataToSend.length, "A greeting");
+        int duration = 0;
+        while (!oft.isDone()) {
+            switch (oft.getStatus()) {
+            case error:
+                throw new Exception("Filetransfer error: " + oft.getError());
+            default:
+                LOGGER.info("Filetransfer status: " + oft.getStatus() + ". Progress: " + oft.getProgress());
+                break;
+            }
+            Thread.sleep(1000);
+            if (++duration > MAX_FT_DURATION) {
+                throw new Exception("Max duration reached");
+            }
+        }
+
+        resultSyncPoint.waitForResult(MAX_FT_DURATION * 1000);
+
+        ftManagerTwo.removeFileTransferListener(receiveListener);
+    }
+}

smack-integration-test/src/main/java/org/jivesoftware/smackx/iqversion/VersionIntegrationTest.java

@@ -0,0 +1,51 @@
+/**
+ *
+ * Copyright 2015 Florian Schmaus
+ *
+ * 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.iqversion;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.igniterealtime.smack.inttest.AbstractSmackIntegrationTest;
+import org.igniterealtime.smack.inttest.SmackIntegrationTest;
+import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
+import org.igniterealtime.smack.inttest.TestNotPossibleException;
+import org.jivesoftware.smack.SmackException.NoResponseException;
+import org.jivesoftware.smack.SmackException.NotConnectedException;
+import org.jivesoftware.smack.XMPPException.XMPPErrorException;
+import org.jivesoftware.smackx.iqversion.packet.Version;
+
+public class VersionIntegrationTest extends AbstractSmackIntegrationTest {
+
+    public VersionIntegrationTest(SmackIntegrationTestEnvironment environment) {
+        super(environment);
+    }
+
+    @SmackIntegrationTest
+    public void testVersion() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException, TestNotPossibleException {
+        // TODO put into @BeforeClass method
+        VersionManager.setAutoAppendSmackVersion(false);
+
+        VersionManager versionManagerOne = VersionManager.getInstanceFor(conOne);
+        VersionManager versionManagerTwo = VersionManager.getInstanceFor(conTwo);
+        final String versionName = "Smack Integration Test " + testRunId;
+        versionManagerTwo.setVersion(versionName, "1.0");
+
+        assertTrue (versionManagerOne.isSupported(conTwo.getUser()));
+        Version version = versionManagerOne.getVersion(conTwo.getUser());
+        assertEquals(versionName, version.getName());
+    }
+}

smack-integration-test/src/main/java/org/jivesoftware/smackx/muc/MultiUserChatIntegrationTest.java

@@ -0,0 +1,97 @@
+/**
+ *
+ * Copyright 2015 Florian Schmaus
+ *
+ * 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.muc;
+
+import java.util.List;
+import java.util.concurrent.TimeoutException;
+
+import org.igniterealtime.smack.inttest.AbstractSmackIntegrationTest;
+import org.igniterealtime.smack.inttest.SmackIntegrationTest;
+import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
+import org.igniterealtime.smack.inttest.TestNotPossibleException;
+import org.igniterealtime.smack.inttest.util.ResultSyncPoint;
+import org.jivesoftware.smack.MessageListener;
+import org.jivesoftware.smack.SmackException.NoResponseException;
+import org.jivesoftware.smack.SmackException.NotConnectedException;
+import org.jivesoftware.smack.XMPPException.XMPPErrorException;
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.util.StringUtils;
+import org.jivesoftware.smackx.xdata.Form;
+import org.jivesoftware.smackx.xdata.packet.DataForm;
+import org.jxmpp.jid.BareJid;
+import org.jxmpp.jid.DomainBareJid;
+import org.jxmpp.jid.impl.JidCreate;
+import org.jxmpp.jid.parts.Localpart;
+import org.jxmpp.jid.parts.Resourcepart;
+
+public class MultiUserChatIntegrationTest extends AbstractSmackIntegrationTest {
+
+    private final String randomString = StringUtils.randomString(6);
+
+    private final MultiUserChatManager mucManagerOne;
+    private final MultiUserChatManager mucManagerTwo;
+    private final DomainBareJid mucService;
+
+    public MultiUserChatIntegrationTest(SmackIntegrationTestEnvironment environment)
+                    throws NoResponseException, XMPPErrorException, NotConnectedException,
+                    InterruptedException, TestNotPossibleException {
+        super(environment);
+        mucManagerOne = MultiUserChatManager.getInstanceFor(conOne);
+        mucManagerTwo = MultiUserChatManager.getInstanceFor(conTwo);
+
+        List<DomainBareJid> services = mucManagerOne.getServiceNames();
+        if (services.isEmpty()) {
+            throw new TestNotPossibleException("No MUC (XEP-45) service found");
+        }
+        else {
+            mucService = services.get(0);
+        }
+    }
+
+    @SmackIntegrationTest
+    public void mucTest() throws TimeoutException, Exception {
+        BareJid mucAddress = JidCreate.bareFrom(Localpart.from("smack-inttest-" + randomString), mucService.getDomain());
+
+        MultiUserChat mucAsSeenByOne = mucManagerOne.getMultiUserChat(mucAddress);
+        MultiUserChat mucAsSeenByTwo = mucManagerTwo.getMultiUserChat(mucAddress);
+
+        final String mucMessage = "Smack Integration Test MUC Test Message " + randomString;
+        final ResultSyncPoint<String, Exception> resultSyncPoint = new ResultSyncPoint<>();
+
+        mucAsSeenByTwo.addMessageListener(new MessageListener() {
+            @Override
+            public void processMessage(Message message) {
+                String body = message.getBody();
+                if (mucMessage.equals(body)) {
+                    resultSyncPoint.signal(body);
+                }
+            }
+        });
+
+        boolean newlyCreated = mucAsSeenByOne.createOrJoin(Resourcepart.from("one-" + randomString));
+        if (newlyCreated) {
+            mucAsSeenByOne.sendConfigurationForm(new Form(DataForm.Type.submit));
+        }
+        mucAsSeenByTwo.join(Resourcepart.from("two-" + randomString));
+
+        mucAsSeenByOne.sendMessage(mucMessage);
+        resultSyncPoint.waitForResult(defaultTimeout);
+
+        mucAsSeenByOne.leave();
+        mucAsSeenByTwo.leave();
+    }
+}

smack-integration-test/src/main/java/org/jivesoftware/smackx/ping/PingIntegrationTest.java

@@ -0,0 +1,38 @@
+/**
+ *
+ * Copyright 2015 Florian Schmaus
+ *
+ * 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.ping;
+
+import static org.junit.Assert.assertTrue;
+
+import org.igniterealtime.smack.inttest.AbstractSmackIntegrationTest;
+import org.igniterealtime.smack.inttest.SmackIntegrationTest;
+import org.igniterealtime.smack.inttest.SmackIntegrationTestEnvironment;
+import org.jivesoftware.smack.SmackException.NotConnectedException;
+
+public class PingIntegrationTest extends AbstractSmackIntegrationTest {
+
+    public PingIntegrationTest(SmackIntegrationTestEnvironment environment) {
+        super(environment);
+    }
+
+    @SmackIntegrationTest
+    public void pingServer() throws NotConnectedException, InterruptedException {
+        PingManager pingManager = PingManager.getInstanceFor(connection);
+        assertTrue(pingManager.pingMyServer());
+    }
+
+}