Migrated ws tests to junit5

Signed-off-by: Ilkin Abdullayev <ilkin.abdullayev@broadcom.com>

Author: Ilkin Abdullayev

gateway-service/src/test/java/org/zowe/apiml/gateway/ws/WebSocketActuatorEndpointTest.java

@@ -0,0 +1,90 @@
+/*
+ * This program and the accompanying materials are made available under the terms of the
+ * Eclipse Public License v2.0 which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-v20.html
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Copyright Contributors to the Zowe Project.
+ */
+
+package org.zowe.apiml.gateway.ws;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.web.socket.WebSocketSession;
+import org.springframework.web.socket.sockjs.transport.session.WebSocketServerSockJsSession;
+
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class WebSocketActuatorEndpointTest {
+
+    private WebSocketActuatorEndpoint webSocketActuatorEndpoint;
+    private WebSocketProxyServerHandler webSocketProxyServerHandler;
+    private WebSocketRoutedSession webSocketRoutedSession;
+    private WebSocketServerSockJsSession webSocketServerSockJsSession;
+    private WebSocketSession session;
+
+    @BeforeEach
+    public void setup() {
+        webSocketProxyServerHandler = mock(WebSocketProxyServerHandler.class);
+        session = mock(WebSocketSession.class);
+        webSocketRoutedSession = mock(WebSocketRoutedSession.class);
+        webSocketServerSockJsSession = mock(WebSocketServerSockJsSession.class);
+
+        webSocketActuatorEndpoint = new WebSocketActuatorEndpoint(webSocketProxyServerHandler);
+    }
+
+    @Test
+    public void should() throws Exception {
+
+        URI uri = new URI("ws://localhost:8080/abc");
+
+        Map<String, WebSocketRoutedSession> routedSessions = new ConcurrentHashMap<>();
+
+        when(webSocketRoutedSession.getWebSocketServerSession()).thenReturn(webSocketServerSockJsSession);
+        when(webSocketRoutedSession.getWebSocketClientSession()).thenReturn(session);
+        when(webSocketRoutedSession.getWebSocketServerSession().getRemoteAddress()).thenReturn(new InetSocketAddress(80));
+        when(webSocketRoutedSession.getWebSocketServerSession().getUri()).thenReturn(uri);
+        when(webSocketRoutedSession.getWebSocketClientSession().getUri()).thenReturn(uri);
+
+        routedSessions.put("websocket", webSocketRoutedSession);
+
+        when(webSocketProxyServerHandler.getRoutedSessions()).thenReturn(routedSessions);
+
+        List<Map<String, String>> expectedResult = getMockedResultMaps();
+
+        List<Map<String, String>> result = webSocketActuatorEndpoint.getAll();
+
+        assertEquals(expectedResult, result);
+    }
+
+    private List<Map<String, String>> getMockedResultMaps() {
+
+        List<Map<String, String>> expectedResult = new ArrayList<>();
+        Map<String, String> map = new LinkedHashMap<>();
+
+        map.put("sessionId", "websocket");
+        map.put("clientAddress", "0.0.0.0/0.0.0.0:80");
+        map.put("gatewayPath", "ws://localhost:8080/abc");
+        map.put("serviceUrl", "ws://localhost:8080/abc");
+        map.put("serviceSessionId", null);
+
+        expectedResult.add(map);
+        return expectedResult;
+    }
+
+}

gateway-service/src/test/java/org/zowe/apiml/gateway/ws/WebSocketProxyServerHandlerTest.java

@@ -0,0 +1,92 @@
+/*
+ * This program and the accompanying materials are made available under the terms of the
+ * Eclipse Public License v2.0 which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-v20.html
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Copyright Contributors to the Zowe Project.
+ */
+
+package org.zowe.apiml.gateway.ws;
+
+import org.apache.http.conn.ssl.TrustStrategy;
+import org.apache.http.ssl.SSLContexts;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+import org.junit.jupiter.api.BeforeEach;
+import org.springframework.cloud.client.DefaultServiceInstance;
+import org.springframework.cloud.client.discovery.DiscoveryClient;
+import org.springframework.web.socket.WebSocketHttpHeaders;
+import org.springframework.web.socket.WebSocketSession;
+import org.zowe.apiml.product.routing.RoutedService;
+import org.zowe.apiml.product.routing.RoutedServices;
+
+import javax.net.ssl.SSLContext;
+import java.net.URI;
+import java.security.cert.X509Certificate;
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class WebSocketProxyServerHandlerTest {
+    private WebSocketSession session;
+    private WebSocketProxyServerHandler webSocketProxyServerHandler;
+    private SslContextFactory jettySslContextFactory;
+    private final DiscoveryClient discoveryClient = mock(DiscoveryClient.class);
+
+
+    @BeforeEach
+    public void setup() {
+        session = mock(WebSocketSession.class);
+//        session = new StandardWebSocketSession();
+//        jettySslContextFactory = mock(SslContextFactory.class);
+        jettySslContextFactory = new SslContextFactory();
+        webSocketProxyServerHandler = new WebSocketProxyServerHandler(discoveryClient, jettySslContextFactory);
+    }
+
+//    @Test
+    public void should() throws Exception {
+        jettySslContextFactory.setKeyStoreType("PKCS12");
+        jettySslContextFactory.setCertAlias("localhost");
+        jettySslContextFactory.setTrustStoreType("type");
+        jettySslContextFactory.setProtocol("SSL");
+        jettySslContextFactory.setKeyStorePath("src/test/resources/certs/keystore.jks");
+        jettySslContextFactory.setTrustStorePath("src/test/resources/certs/truststore.jks");
+        jettySslContextFactory.setKeyManagerFactoryAlgorithm("SunX509");
+        jettySslContextFactory.setTrustManagerFactoryAlgorithm("PKIX");
+        jettySslContextFactory.setKeyStorePassword("pass");
+        jettySslContextFactory.setTrustStorePassword("pass");
+        TrustStrategy acceptingTrustStrategy = new TrustStrategy() {
+            public boolean isTrusted(X509Certificate[] certificate, String authType) {
+                return true;
+            }
+        };
+        SSLContext sslContext = SSLContexts.custom()
+            .loadTrustMaterial(null, acceptingTrustStrategy).build();
+//        SSLContext sslContext = SSLContext.getInstance("SSL");
+
+        jettySslContextFactory.setSslContext(sslContext);
+//        when(session.isOpen()).thenReturn(true);
+        RoutedServices routedServices = new RoutedServices();
+        routedServices.addRoutedService(
+            new RoutedService("api-v1", "api/v1", "/service/api/v1"));
+        routedServices.addRoutedService(
+            new RoutedService("ui-v1", "ui/v1", "/service"));
+        routedServices.addRoutedService(
+            new RoutedService("ws-v1", "ws/v1", "/service/ws"));
+        WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
+
+        headers.add("X-Test", "value");
+        when(session.getUri()).thenReturn(new URI("/ws/v1/service/uppercase"));
+        when(discoveryClient.getInstances("service")).thenReturn(
+            Collections.singletonList(new DefaultServiceInstance("service", "localhost", 80, false, null)));
+        when(session.getHandshakeHeaders()).thenReturn(headers);
+        webSocketProxyServerHandler.addRoutedServices("service", routedServices);
+        webSocketProxyServerHandler.afterConnectionEstablished(session);
+        assertTrue(session.isOpen());
+
+    }
+
+
+}