Introduce websocket module into smack

smack-websocket/src/test/java/org/jivesoftware/smack/websocket/WebsocketConnectionAttemptStateTest.java

@@ -0,0 +1,28 @@
+/**
+ *
+  * Copyright 2020 Aditya Borikar
+ *
+ * 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.websocket;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+public class WebsocketConnectionAttemptStateTest {
+    @Test
+    public void constructorTest() {
+        assertThrows(AssertionError.class, () -> new WebsocketConnectionAttemptState(null, null, null));
+    }
+}

smack-websocket/src/test/java/org/jivesoftware/smack/websocket/WebsocketInitializerTest.java

@@ -0,0 +1,32 @@
+/**
+ *
+ * Copyright 2020 Aditya Borikar
+ *
+ * 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.websocket;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+public class WebsocketInitializerTest {
+    @Test
+    public void testExtensionInitializer() {
+        WebsocketInitializer initializer = new WebsocketInitializer();
+        List<Exception> exceptions = initializer.initialize();
+        assertTrue(exceptions.size() == 0);
+    }
+}

smack-websocket/src/test/java/org/jivesoftware/smack/websocket/XmppWebsocketTransportModuleTest.java

@@ -0,0 +1,124 @@
+/**
+ *
+ * Copyright 2020 Aditya Borikar
+ *
+ * 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.websocket;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import static org.mockito.Mockito.mock;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.jivesoftware.smack.c2s.ModularXmppClientToServerConnection;
+import org.jivesoftware.smack.c2s.ModularXmppClientToServerConnectionConfiguration;
+import org.jivesoftware.smack.c2s.internal.ModularXmppClientToServerConnectionInternal;
+import org.jivesoftware.smack.util.rce.RemoteConnectionEndpointLookupFailure;
+import org.jivesoftware.smack.util.rce.RemoteConnectionEndpointLookupFailure.HttpLookupFailure;
+import org.jivesoftware.smack.websocket.XmppWebsocketTransportModule.XmppWebsocketTransport.DiscoveredWebsocketEndpoints;
+import org.jivesoftware.smack.websocket.XmppWebsocketTransportModule.XmppWebsocketTransport.WebsocketEndpointsDiscoveryFailed;
+import org.jivesoftware.smack.websocket.rce.WebsocketRemoteConnectionEndpoint;
+import org.jivesoftware.smack.websocket.rce.WebsocketRemoteConnectionEndpointLookup.Result;
+
+import org.junit.jupiter.api.Test;
+import org.jxmpp.stringprep.XmppStringprepException;
+
+public class XmppWebsocketTransportModuleTest {
+    @Test
+    public void createWebsocketModuleConnectionInstanceTest() throws URISyntaxException, XmppStringprepException {
+        ModularXmppClientToServerConnectionConfiguration.Builder builder = ModularXmppClientToServerConnectionConfiguration
+                .builder();
+
+        builder.removeAllModules();
+        builder.addModule(XmppWebsocketTransportModuleDescriptor.class);
+        builder.setXmppAddressAndPassword("user5@localhost.org", "user5");
+        builder.setHost("localhost.org");
+
+        XmppWebsocketTransportModuleDescriptor.Builder websocketBuilder = XmppWebsocketTransportModuleDescriptor.getBuilder(builder);
+        websocketBuilder.explicitlySetWebsocketEndpointAndDiscovery(new URI("wss://localhost.org:7443/ws/"), false);
+
+        ModularXmppClientToServerConnectionConfiguration config = builder.build();
+        ModularXmppClientToServerConnection connection = new ModularXmppClientToServerConnection(config);
+        assertNotNull(connection);
+    }
+
+    @Test
+    public void createDescriptorTest() throws URISyntaxException, XmppStringprepException {
+        XmppWebsocketTransportModuleDescriptor websocketTransportModuleDescriptor = getWebsocketDescriptor();
+        assertNotNull(websocketTransportModuleDescriptor);
+    }
+
+    @Test
+    public void websocketEndpointDiscoveryTest() throws URISyntaxException {
+        XmppWebsocketTransportModuleDescriptor websocketTransportModuleDescriptor = getWebsocketDescriptor();
+        ModularXmppClientToServerConnectionInternal connectionInternal = mock(ModularXmppClientToServerConnectionInternal.class);
+
+        XmppWebsocketTransportModule transportModule
+                        = new XmppWebsocketTransportModule(websocketTransportModuleDescriptor, connectionInternal);
+
+        XmppWebsocketTransportModule.XmppWebsocketTransport transport = transportModule.getTransport();
+
+        assertThrows(AssertionError.class, () -> transport.new DiscoveredWebsocketEndpoints(null));
+        assertThrows(AssertionError.class, () -> transport.new WebsocketEndpointsDiscoveryFailed(null));
+
+        WebsocketRemoteConnectionEndpoint endpoint = new WebsocketRemoteConnectionEndpoint("wss://localhost.org:7443/ws/");
+
+        List<WebsocketRemoteConnectionEndpoint> discoveredRemoteConnectionEndpoints = new ArrayList<>();
+        discoveredRemoteConnectionEndpoints.add(endpoint);
+
+        HttpLookupFailure httpLookupFailure = new RemoteConnectionEndpointLookupFailure.HttpLookupFailure(null, null);
+        List<RemoteConnectionEndpointLookupFailure> failureList = new ArrayList<>();
+        failureList.add(httpLookupFailure);
+        Result result = new Result(discoveredRemoteConnectionEndpoints, failureList);
+
+        DiscoveredWebsocketEndpoints discoveredWebsocketEndpoints = transport.new DiscoveredWebsocketEndpoints(result);
+        assertNotNull(discoveredWebsocketEndpoints.getResult());
+
+        WebsocketEndpointsDiscoveryFailed endpointsDiscoveryFailed = transport.new WebsocketEndpointsDiscoveryFailed(result);
+        assertNotNull(endpointsDiscoveryFailed.toString());
+    }
+
+    @Test
+    public void websocketConnectedResultTest() throws URISyntaxException {
+        WebsocketRemoteConnectionEndpoint connectedEndpoint = new WebsocketRemoteConnectionEndpoint("wss://localhost.org:7443/ws/");
+        assertNotNull(new XmppWebsocketTransportModule.WebsocketConnectedResult(connectedEndpoint));
+    }
+
+    @Test
+    public void lookupConnectionEndpointsTest() throws URISyntaxException {
+        XmppWebsocketTransportModuleDescriptor websocketTransportModuleDescriptor = getWebsocketDescriptor();
+        ModularXmppClientToServerConnectionInternal connectionInternal = mock(ModularXmppClientToServerConnectionInternal.class);
+
+        XmppWebsocketTransportModule transportModule
+                        = new XmppWebsocketTransportModule(websocketTransportModuleDescriptor, connectionInternal);
+
+        XmppWebsocketTransportModule.XmppWebsocketTransport transport = transportModule.getTransport();
+        assertNotNull(transport.lookupConnectionEndpoints());
+
+    }
+
+    private static XmppWebsocketTransportModuleDescriptor getWebsocketDescriptor() throws URISyntaxException {
+        ModularXmppClientToServerConnectionConfiguration.Builder builder = ModularXmppClientToServerConnectionConfiguration
+                .builder();
+
+        XmppWebsocketTransportModuleDescriptor.Builder websocketBuilder = XmppWebsocketTransportModuleDescriptor.getBuilder(builder);
+        websocketBuilder.explicitlySetWebsocketEndpointAndDiscovery(new URI("wss://localhost.org:7443/ws/"), false);
+        return (XmppWebsocketTransportModuleDescriptor) websocketBuilder.build();
+    }
+}

smack-websocket/src/test/java/org/jivesoftware/smack/websocket/elements/WebsocketElementTest.java

@@ -0,0 +1,43 @@
+/**
+ *
+ * Copyright 2020 Aditya Borikar
+ *
+ * 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.websocket.elements;
+
+import static org.jivesoftware.smack.test.util.XmlAssertUtil.assertXmlNotSimilar;
+import static org.jivesoftware.smack.test.util.XmlAssertUtil.assertXmlSimilar;
+
+import org.junit.jupiter.api.Test;
+import org.jxmpp.jid.impl.JidCreate;
+import org.jxmpp.stringprep.XmppStringprepException;
+
+public class WebsocketElementTest {
+    private static final String OPEN_ELEMENT = "<open xmlns='urn:ietf:params:xml:ns:xmpp-framing' to='foodomain.foo' version='1.0'/>";
+    private static final String CLOSE_ELEMENT = "<close xmlns='urn:ietf:params:xml:ns:xmpp-framing'/>";
+
+    @Test
+    public void websocketOpenElementTest() throws XmppStringprepException {
+        String openElementXml =  new WebsocketOpenElement(JidCreate.domainBareFrom("foodomain.foo")).toXML().toString();
+        assertXmlSimilar(OPEN_ELEMENT, openElementXml);
+        assertXmlNotSimilar(CLOSE_ELEMENT, new WebsocketOpenElement(JidCreate.domainBareFrom("foodomain.foo")).toXML());
+    }
+
+    @Test
+    public void websocketCloseElementTest() throws XmppStringprepException {
+        String closeElementXml = new WebsocketCloseElement().toXML().toString();
+        assertXmlSimilar(CLOSE_ELEMENT, closeElementXml);
+        assertXmlNotSimilar(OPEN_ELEMENT, closeElementXml);
+    }
+}

smack-websocket/src/test/java/org/jivesoftware/smack/websocket/implementations/AbstractWebsocketTest.java

@@ -0,0 +1,47 @@
+/**
+ *
+ * Copyright 2020 Aditya Borikar.
+ *
+ * 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.websocket.implementations;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public final class AbstractWebsocketTest {
+    private static final String OPEN_ELEMENT = "<open from='localhost.org' id='aov9ihhmmn' xmlns='urn:ietf:params:xml:ns:xmpp-framing' xml:lang='en' version='1.0'/>";
+    private static final String OPEN_STREAM = "<stream from='localhost.org' id='aov9ihhmmn' xmlns='jabber:client' xml:lang='en' version='1.0'>";
+    private static final String CLOSE_ELEMENT = "<close xmlns='urn:ietf:params:xml:ns:xmpp-framing'/>";
+
+    @Test
+    public void getStreamFromOpenElementTest() {
+        String generatedOpenStream = AbstractWebsocket.getStreamFromOpenElement(OPEN_ELEMENT);
+        assertEquals(generatedOpenStream, OPEN_STREAM);
+    }
+
+    @Test
+    public void isOpenElementTest() {
+        assertTrue(AbstractWebsocket.isOpenElement(OPEN_ELEMENT));
+        assertFalse(AbstractWebsocket.isOpenElement(OPEN_STREAM));
+    }
+
+    @Test
+    public void isCloseElementTest() {
+        assertTrue(AbstractWebsocket.isCloseElement(CLOSE_ELEMENT));
+        assertFalse(AbstractWebsocket.isCloseElement(OPEN_STREAM));
+    }
+}

smack-websocket/src/test/java/org/jivesoftware/smack/websocket/implementations/ProviderTest.java

@@ -0,0 +1,61 @@
+/**
+ *
+ * Copyright 2020 Aditya Borikar.
+ *
+ * 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.websocket.implementations;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.lang.reflect.InvocationTargetException;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.jivesoftware.smack.c2s.internal.ModularXmppClientToServerConnectionInternal;
+import org.jivesoftware.smack.websocket.XmppWebsocketTransportModule.XmppWebsocketTransport.DiscoveredWebsocketEndpoints;
+
+import org.jivesoftware.smack.websocket.implementations.okhttp.OkHttpWebsocket;
+import org.jivesoftware.smack.websocket.rce.WebsocketRemoteConnectionEndpoint;
+import org.jivesoftware.smack.websocket.rce.WebsocketRemoteConnectionEndpointLookup.Result;
+
+import org.junit.jupiter.api.Test;
+
+public class ProviderTest {
+    @Test
+    public void providerTest() {
+        assertThrows(IllegalArgumentException.class, () -> WebsocketImplProvider.getWebsocketImpl(OkHttpWebsocket.class, null, null));
+    }
+
+    @Test
+    public void getImplTest() throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, URISyntaxException {
+        WebsocketRemoteConnectionEndpoint endpoint = new WebsocketRemoteConnectionEndpoint("wss://localhost.org:7443/ws/");
+
+        List<WebsocketRemoteConnectionEndpoint> discoveredRemoteConnectionEndpoints = new ArrayList<>();
+        discoveredRemoteConnectionEndpoints.add(endpoint);
+
+        Result result = new Result(discoveredRemoteConnectionEndpoints, null);
+
+        DiscoveredWebsocketEndpoints discoveredWebsocketEndpoints = mock(DiscoveredWebsocketEndpoints.class);
+        when(discoveredWebsocketEndpoints.getResult()).thenReturn(result);
+
+        ModularXmppClientToServerConnectionInternal connectionInternal = mock(ModularXmppClientToServerConnectionInternal.class);
+
+        assertNotNull(WebsocketImplProvider.getWebsocketImpl(OkHttpWebsocket.class, connectionInternal, discoveredWebsocketEndpoints));
+    }
+}

smack-websocket/src/test/java/org/jivesoftware/smack/websocket/rce/WebsocketRemoteConnectionEndpointTest.java

@@ -0,0 +1,45 @@
+/**
+ *
+ * Copyright 2020 Aditya Borikar
+ *
+ * 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.websocket.rce;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.net.URISyntaxException;
+
+import org.jivesoftware.smack.datatypes.UInt16;
+
+import org.junit.jupiter.api.Test;
+
+public class WebsocketRemoteConnectionEndpointTest {
+    @Test
+    public void endpointTest() throws URISyntaxException {
+        String endpointString = "ws://fooDomain.org:7070/ws/";
+        WebsocketRemoteConnectionEndpoint endpoint = new WebsocketRemoteConnectionEndpoint(endpointString);
+        assertEquals("fooDomain.org", endpoint.getHost());
+        assertEquals(UInt16.from(7070), endpoint.getPort());
+        assertEquals(endpointString, endpoint.getWebsocketEndpoint().toString());
+    }
+
+    @Test
+    public void faultyEndpointTest() {
+        String faultyProtocolString = "wst://fooDomain.org:7070/ws/";
+        assertThrows(IllegalArgumentException.class, () -> {
+            new WebsocketRemoteConnectionEndpoint(faultyProtocolString);
+        });
+    }
+}