[SCB-2631]migrate foundation-vertx module to mockito part 1

foundations/foundation-vertx/pom.xml

@@ -60,6 +60,11 @@
       <artifactId>jmockit</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-inline</artifactId>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.apache.servicecomb</groupId>
       <artifactId>foundation-test-scaffolding</artifactId>

foundations/foundation-vertx/src/test/java/org/apache/servicecomb/foundation/vertx/client/TestClientPoolManager.java

@@ -36,6 +36,8 @@
 import mockit.MockUp;
 import mockit.Mocked;
 import org.junit.jupiter.api.Assertions;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 
 public class TestClientPoolManager {
   @Mocked
@@ -200,38 +202,30 @@ public void findByContext_normalThread() {
   }
 
   @Test
-  public void findByContext_otherVertx(@Mocked VertxImpl otherVertx, @Mocked Context otherContext) {
+  public void findByContext_otherVertx() {
     HttpClientWithContext pool = new HttpClientWithContext(null, null);
     pools.add(pool);
 
-    new Expectations() {
-      {
-        Vertx.currentContext();
-        result = otherContext;
-        otherContext.owner();
-        result = otherVertx;
-      }
-    };
-
-    Assertions.assertSame(pool, poolMgr.findByContext());
+    Context otherContext = Mockito.mock(Context.class);
+    VertxImpl otherVertx = Mockito.mock(VertxImpl.class);
+    try (MockedStatic<Vertx> vertxMockedStatic = Mockito.mockStatic(Vertx.class)) {
+      vertxMockedStatic.when(Vertx::currentContext).thenReturn(otherContext);
+      Mockito.when(otherContext.owner()).thenReturn(otherVertx);
+      Assertions.assertSame(pool, poolMgr.findByContext());
+    }
   }
 
   @Test
-  public void findByContext_worker(@Mocked Context workerContext) {
+  public void findByContext_worker() {
     HttpClientWithContext pool = new HttpClientWithContext(null, null);
     pools.add(pool);
 
-    new Expectations() {
-      {
-        Vertx.currentContext();
-        result = workerContext;
-        workerContext.owner();
-        result = vertx;
-        workerContext.isEventLoopContext();
-        result = false;
-      }
-    };
-
-    Assertions.assertSame(pool, poolMgr.findByContext());
+    Context workerContext = Mockito.mock(Context.class);
+    try (MockedStatic<Vertx> vertxMockedStatic = Mockito.mockStatic(Vertx.class)) {
+      vertxMockedStatic.when(Vertx::currentContext).thenReturn(workerContext);
+      Mockito.when(workerContext.owner()).thenReturn(vertx);
+      Mockito.when(workerContext.isEventLoopContext()).thenReturn(false);
+      Assertions.assertSame(pool, poolMgr.findByContext());
+    }
   }
 }

foundations/foundation-vertx/src/test/java/org/apache/servicecomb/foundation/vertx/client/tcp/TestNetClientWrapper.java

@@ -22,86 +22,80 @@
 
 import org.hamcrest.MatcherAssert;
 import org.hamcrest.Matchers;
-import org.junit.Before;
-import org.junit.Test;
+
 
 import io.vertx.core.AsyncResult;
 import io.vertx.core.Handler;
 import io.vertx.core.Promise;
 import io.vertx.core.Vertx;
 import io.vertx.core.net.NetClient;
 import io.vertx.core.net.NetSocket;
-import mockit.Expectations;
-import mockit.Mock;
-import mockit.MockUp;
-import mockit.Mocked;
+
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.mockito.Mock;
+import org.mockito.Mockito;
 
 public class TestNetClientWrapper {
-  @Mocked
+
   Vertx vertx;
 
-  @Mocked
   TcpClientConfig normalClientConfig;
 
-  @Mocked
   NetClient normalNetClient;
 
-  @Mocked
   TcpClientConfig sslClientConfig;
 
-  @Mocked
   NetClient sslNetClient;
 
   NetClientWrapper netClientWrapper;
 
-  @Before
+  @Mock
+  NetSocket normalSocket;
+
+  @Mock
+  NetSocket sslSocket;
+
+  @BeforeEach
   public void setup() {
-    new Expectations() {
-      {
-        vertx.createNetClient(normalClientConfig);
-        result = normalNetClient;
-        vertx.createNetClient(sslClientConfig);
-        result = sslNetClient;
-      }
-    };
+    vertx = Mockito.mock(Vertx.class);
+    normalClientConfig = Mockito.mock(TcpClientConfig.class);
+    normalNetClient = Mockito.mock(NetClient.class);
+    sslClientConfig = Mockito.mock(TcpClientConfig.class);
+    sslNetClient = Mockito.mock(NetClient.class);
+    Mockito.when(vertx.createNetClient(normalClientConfig)).thenReturn(normalNetClient);
+    Mockito.when(vertx.createNetClient(sslClientConfig)).thenReturn(sslNetClient);
     netClientWrapper = new NetClientWrapper(vertx, normalClientConfig, sslClientConfig);
   }
 
-  @Test
+  @org.junit.jupiter.api.Test
   public void getClientConfig() {
     Assertions.assertSame(normalClientConfig, netClientWrapper.getClientConfig(false));
     Assertions.assertSame(sslClientConfig, netClientWrapper.getClientConfig(true));
   }
 
-  @Test
-  public void connect(@Mocked NetSocket normalSocket, @Mocked NetSocket sslSocket) {
+  @org.junit.jupiter.api.Test
+  public void connect() {
     int port = 8000;
     String host = "localhost";
 
+    List<NetSocket> socks = new ArrayList<>();
     Promise<NetSocket> promiseConnect = Promise.promise();
-    new MockUp<NetClient>(normalNetClient) {
-      @Mock
-      NetClient connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler) {
-        promiseConnect.complete(normalSocket);
-        connectHandler.handle(promiseConnect.future());
-        return null;
-      }
-    };
-
     Promise<NetSocket> sslPromiseConnect = Promise.promise();
-    new MockUp<NetClient>(sslNetClient) {
-      @Mock
-      NetClient connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler) {
-        sslPromiseConnect.complete(sslSocket);
-        connectHandler.handle(sslPromiseConnect.future());
-        return null;
-      }
-    };
-
-    List<NetSocket> socks = new ArrayList<>();
-    netClientWrapper.connect(false, port, host, asyncSocket -> socks.add(asyncSocket.result()));
-    netClientWrapper.connect(true, port, host, asyncSocket -> socks.add(asyncSocket.result()));
+    Handler<AsyncResult<NetSocket>> connectHandler = asyncSocket -> socks.add(asyncSocket.result());
+    Mockito.when(normalNetClient.connect(port, host, connectHandler)).thenAnswer(invocation -> {
+      promiseConnect.complete(normalSocket);
+      connectHandler.handle(promiseConnect.future());
+      return null;
+    });
+    Mockito.when(sslNetClient.connect(port, host, connectHandler)).thenAnswer(invocationOnMock -> {
+      sslPromiseConnect.complete(sslSocket);
+      connectHandler.handle(sslPromiseConnect.future());
+      return null;
+    });
+
+    netClientWrapper.connect(false, port, host, connectHandler);
+    netClientWrapper.connect(true, port, host, connectHandler);
 
     MatcherAssert.assertThat(socks, Matchers.contains(normalSocket, sslSocket));
   }