Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
VertxClientResponseToHttpServletResponse extends AbstractHttpServletResponse { @Override public String getContentType() { return clientResponse.getHeader(HttpHeaders.CONTENT_TYPE); } VertxClientResponseToHttpServletResponse(HttpClientResponse clientResponse, Buffer bodyBuffer); @Override int getStatus(); @Override StatusType getStatusType(); @Override String getContentType(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
@Test public void getContentType() { new Expectations() { { clientResponse.getHeader(HttpHeaders.CONTENT_TYPE); result = "json"; } }; Assert.assertEquals("json", response.getContentType()); }
VertxClientResponseToHttpServletResponse extends AbstractHttpServletResponse { @Override public String getHeader(String name) { return clientResponse.getHeader(name); } VertxClientResponseToHttpServletResponse(HttpClientResponse clientResponse, Buffer bodyBuffer); @Override int getStatus(); @Override StatusType getStatusType(); @Override String getContentType(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
@Test public void getHeader() { new Expectations() { { clientResponse.getHeader("name"); result = "value"; } }; Assert.assertEquals("value", response.getHeader("name")); }
VertxClientResponseToHttpServletResponse extends AbstractHttpServletResponse { @Override public Collection<String> getHeaders(String name) { return clientResponse.headers().getAll(name); } VertxClientResponseToHttpServletResponse(HttpClientResponse clientResponse, Buffer bodyBuffer); @Override int getStatus(); @Override StatusType getStatusType(); @Override String getContentType(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
@Test public void getHeaders() { MultiMap headers = MultiMap.caseInsensitiveMultiMap(); headers.add("name", "v1"); headers.add("name", "v2"); new Expectations() { { clientResponse.headers(); result = headers; } }; Assert.assertThat(response.getHeaders("name"), Matchers.contains("v1", "v2")); }
VertxClientResponseToHttpServletResponse extends AbstractHttpServletResponse { @Override public Collection<String> getHeaderNames() { return clientResponse.headers().names(); } VertxClientResponseToHttpServletResponse(HttpClientResponse clientResponse, Buffer bodyBuffer); @Override int getStatus(); @Override StatusType getStatusType(); @Override String getContentType(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); }
@Test public void getHeaderNames() { MultiMap headers = MultiMap.caseInsensitiveMultiMap(); headers.add("n1", "v1"); headers.add("n2", "v2"); new Expectations() { { clientResponse.headers(); result = headers; } }; Assert.assertThat(response.getHeaderNames(), Matchers.contains("n1", "n2")); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getRequestURI() { if (this.path == null) { this.path = vertxRequest.path(); } return this.path; } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void constructWithPath() { request = new VertxServerRequestToHttpServletRequest(context, "/path"); Assert.assertEquals("/path", request.getRequestURI()); } @Test public void testGetRequestURI() { new Expectations() { { vertxRequest.path(); result = "/path"; } }; Assert.assertEquals("/path", request.getRequestURI()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public void setBodyBuffer(Buffer bodyBuffer) { super.setBodyBuffer(bodyBuffer); context.setBody(bodyBuffer); this.inputStream = null; } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void setBodyBuffer() { Holder<Buffer> bodyHolder = new Holder<>(); context = new MockUp<RoutingContext>() { @Mock HttpServerRequest request() { return vertxRequest; } @Mock void setBody(Buffer body) { bodyHolder.value = body; } }.getMockInstance(); request = new VertxServerRequestToHttpServletRequest(context); Buffer bodyBuffer = Buffer.buffer(); request.setBodyBuffer(bodyBuffer); Assert.assertSame(bodyBuffer, bodyHolder.value); Assert.assertSame(bodyBuffer, request.getBodyBuffer()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getContentType() { return this.vertxRequest.getHeader(HttpHeaders.CONTENT_TYPE); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetContentType() { new Expectations() { { vertxRequest.getHeader(HttpHeaders.CONTENT_TYPE); result = "json"; } }; Assert.assertEquals("json", request.getContentType()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public Cookie[] getCookies() { if (cookies == null) { Map<String, io.vertx.core.http.Cookie> vertxCookies = context.cookieMap(); Cookie tmpCookies[] = new Cookie[vertxCookies.size()]; int idx = 0; for (io.vertx.core.http.Cookie oneVertxCookie : vertxCookies.values()) { Cookie cookie = new Cookie(oneVertxCookie.getName(), oneVertxCookie.getValue()); tmpCookies[idx] = cookie; idx++; } cookies = tmpCookies; } return cookies; } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetCookies() { Map<String, io.vertx.core.http.Cookie> vertxCookies = new LinkedHashMap<>(); vertxCookies.put("c1", io.vertx.core.http.Cookie.cookie("c1", "c1v")); vertxCookies.put("c2", io.vertx.core.http.Cookie.cookie("c2", "c2v")); new Expectations() { { context.cookieMap(); result = vertxCookies; } }; Cookie[] cookies = request.getCookies(); Assert.assertEquals("c1", cookies[0].getName()); Assert.assertEquals("c1v", cookies[0].getValue()); Assert.assertEquals("c2", cookies[1].getName()); Assert.assertEquals("c2v", cookies[1].getValue()); Assert.assertSame(cookies, request.getCookies()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getParameter(String name) { if (parameterMap != null) { String[] values = parameterMap.get(name); return values == null ? null : values[0]; } return this.vertxRequest.getParam(name); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetParameter() { new Expectations() { { vertxRequest.getParam("name"); result = "value"; } }; Assert.assertEquals("value", request.getParameter("name")); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String[] getParameterValues(String name) { if (parameterMap != null) { return parameterMap.get(name); } List<String> paramList = this.vertxRequest.params().getAll(name); return paramList.toArray(new String[paramList.size()]); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetParameterValuesNull() { Assert.assertEquals(0, request.getParameterValues("name").length); } @Test public void testGetParameterValuesNormal() { MultiMap params = MultiMap.caseInsensitiveMultiMap(); params.add("name", "value"); new Expectations() { { vertxRequest.params(); result = params; } }; Assert.assertThat(request.getParameterValues("name"), Matchers.arrayContaining("value")); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public Map<String, String[]> getParameterMap() { if (parameterMap == null) { Map<String, String[]> paramMap = new HashMap<>(); MultiMap map = this.vertxRequest.params(); for (String name : map.names()) { List<String> valueList = map.getAll(name); paramMap.put(name, map.getAll(name).toArray(new String[valueList.size()])); } parameterMap = paramMap; } return parameterMap; } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetParameterMap() { MultiMap params = MultiMap.caseInsensitiveMultiMap(); params.add("name", "value"); new Expectations() { { vertxRequest.params(); result = params; } }; Map<String, String[]> result = request.getParameterMap(); Assert.assertThat(result.keySet(), Matchers.contains("name")); Assert.assertThat(result.get("name"), Matchers.arrayContaining("value")); Assert.assertSame(result, request.getParameterMap()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getScheme() { return this.vertxRequest.scheme(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testScheme() { new Expectations() { { vertxRequest.scheme(); result = "abc"; } }; Assert.assertEquals("abc", request.getScheme()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getRemoteAddr() { return this.socketAddress.host(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetRemoteAddr() { new Expectations() { { socketAddress.host(); result = "host"; } }; Assert.assertEquals("host", request.getRemoteAddr()); } @Test public void testGetRemoteAddrNull() { new Expectations() { { socketAddress.host(); result = null; } }; Assert.assertEquals(null, request.getRemoteAddr()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getRemoteHost() { return this.socketAddress.host(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetRemoteHost() { new Expectations() { { socketAddress.host(); result = "host"; } }; Assert.assertEquals("host", request.getRemoteHost()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public int getRemotePort() { return this.socketAddress.port(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetRemotePort() { new Expectations() { { socketAddress.port(); result = 1234; } }; Assert.assertEquals(1234, request.getRemotePort()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getLocalAddr() { return this.vertxRequest.localAddress().host(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetgetLocalAddr(@Mocked SocketAddress sa) { new Expectations() { { sa.host(); result = "host"; vertxRequest.localAddress(); result = sa; } }; Assert.assertEquals("host", request.getLocalAddr()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public int getLocalPort() { return this.vertxRequest.localAddress().port(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetLocalPort(@Mocked SocketAddress sa) { new Expectations() { { sa.port(); result = 1234; vertxRequest.localAddress(); result = sa; } }; Assert.assertEquals(1234, request.getLocalPort()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getHeader(String name) { return this.vertxRequest.getHeader(name); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetHeader() { new Expectations() { { vertxRequest.getHeader("key"); result = "value"; } }; Assert.assertEquals("value", request.getHeader("key")); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public Enumeration<String> getHeaders(String name) { return Collections.enumeration(this.vertxRequest.headers().getAll(name)); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetHeaders() { MultiMap headers = MultiMap.caseInsensitiveMultiMap(); headers.add("name", "value"); new Expectations() { { vertxRequest.headers(); result = headers; } }; Assert.assertThat(Collections.list(request.getHeaders("name")), Matchers.contains("value")); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public Enumeration<String> getHeaderNames() { return Collections.enumeration(vertxRequest.headers().names()); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetHeaderNames() { MultiMap headers = MultiMap.caseInsensitiveMultiMap(); headers.add("name", "value"); new Expectations() { { vertxRequest.headers(); result = headers; } }; Assert.assertThat(Collections.list(request.getHeaderNames()), Matchers.contains("name")); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public int getIntHeader(String name) { String header = this.vertxRequest.getHeader(name); if (header == null) { return -1; } return Integer.parseInt(header); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetIntHeaderNotExist() { Assert.assertEquals(-1, request.getIntHeader("key")); }
ServiceCenterTask implements Runnable { public void init() { microserviceServiceCenterTask.run(); } ServiceCenterTask(EventBus eventBus, int interval, int checkTimes, MicroserviceServiceCenterTask microserviceServiceCenterTask); @Subscribe void onRegisterTask(AbstractRegisterTask task); @Subscribe void onMicroserviceInstanceHeartbeatTask(MicroserviceInstanceHeartbeatTask task); @Subscribe void onExceptionEvent(ExceptionEvent event); void init(); @Override void run(); @VisibleForTesting boolean getSafeMode(); }
@Test public void testLifeCycleException(@Mocked MicroserviceInstanceRegisterTask instanceEvent, @Mocked MicroserviceInstanceHeartbeatTask heartBeatEvent) { new Expectations() { { instanceEvent.getTaskStatus(); result = TaskStatus.FINISHED; heartBeatEvent.getHeartbeatResult(); result = HeartbeatResult.DISCONNECTED; } }; serviceCenterTask.init(); eventBus.post(instanceEvent); Assert.assertTrue(Deencapsulation.getField(serviceCenterTask, "registerInstanceSuccess")); eventBus.post(heartBeatEvent); Assert.assertFalse(Deencapsulation.getField(serviceCenterTask, "registerInstanceSuccess")); } @Test public void testLifeCycleSuccess(@Mocked MicroserviceInstanceRegisterTask instanceEvent, @Mocked MicroserviceInstanceHeartbeatTask heartBeatEvent) { new Expectations() { { instanceEvent.getTaskStatus(); result = TaskStatus.FINISHED; heartBeatEvent.getHeartbeatResult(); result = HeartbeatResult.SUCCESS; } }; serviceCenterTask.init(); eventBus.post(instanceEvent); Assert.assertTrue(Deencapsulation.getField(serviceCenterTask, "registerInstanceSuccess")); eventBus.post(heartBeatEvent); Assert.assertTrue(Deencapsulation.getField(serviceCenterTask, "registerInstanceSuccess")); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getMethod() { return this.vertxRequest.method().name(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetMethod() { new Expectations() { { vertxRequest.method(); result = HttpMethod.GET; } }; Assert.assertEquals("GET", request.getMethod()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getPathInfo() { return this.vertxRequest.path(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetPathInfo() { new Expectations() { { vertxRequest.path(); result = "/path"; } }; Assert.assertEquals("/path", request.getPathInfo()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getQueryString() { return this.vertxRequest.query(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetQueryString() { new Expectations() { { vertxRequest.query(); result = "k1=v1&k2=v2"; } }; Assert.assertEquals("k1=v1&k2=v2", request.getQueryString()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getServletPath() { return this.getPathInfo(); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetServletPath() { new Expectations() { { vertxRequest.path(); result = "/path"; } }; Assert.assertEquals("/path", request.getServletPath()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getContextPath() { return ""; } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetContextPath() { Assert.assertEquals("", request.getContextPath()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public ServletInputStream getInputStream() { if (inputStream == null) { inputStream = new BufferInputStream(context.getBody().getByteBuf()); } return inputStream; } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetInputStream() throws IOException { Buffer body = Buffer.buffer(); body.appendByte((byte) 1); new Expectations() { { context.getBody(); result = body; } }; ServletInputStream is1 = request.getInputStream(); Assert.assertSame(is1, request.getInputStream()); int value = is1.read(); is1.close(); Assert.assertEquals(1, value); Assert.assertSame(is1, request.getInputStream()); request.setBodyBuffer(Buffer.buffer().appendByte((byte)2)); ServletInputStream is2 = request.getInputStream(); Assert.assertNotSame(is1, is2); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public AsyncContext getAsyncContext() { return EMPTY_ASYNC_CONTEXT; } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void testGetAsyncContext() { AsyncContext asyncContext = Deencapsulation.getField(VertxServerRequestToHttpServletRequest.class, "EMPTY_ASYNC_CONTEXT"); Assert.assertSame(asyncContext, request.getAsyncContext()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public String getCharacterEncoding() { if (characterEncoding == null) { characterEncoding = HttpUtils.getCharsetFromContentType(getContentType()); } return characterEncoding; } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void getCharacterEncoding() { new Expectations(HttpUtils.class) { { vertxRequest.getHeader(HttpHeaders.CONTENT_TYPE); result = "ct"; HttpUtils.getCharsetFromContentType("ct"); result = "ce"; } }; Assert.assertEquals("ce", request.getCharacterEncoding()); }
VertxServerRequestToHttpServletRequest extends AbstractHttpServletRequest { @Override public void setParameter(String name, String value) { if (parameterMap != null) { parameterMap.put(name, new String[] {value}); return; } vertxRequest.params().set(name, value); } VertxServerRequestToHttpServletRequest(RoutingContext context, String path); VertxServerRequestToHttpServletRequest(RoutingContext context); @Override void setBodyBuffer(Buffer bodyBuffer); @Override String getContentType(); @Override Cookie[] getCookies(); @Override String getParameter(String name); @Override Enumeration<String> getParameterNames(); @Override String[] getParameterValues(String name); @Override Map<String, String[]> getParameterMap(); @Override void setParameter(String name, String value); @Override String getScheme(); @Override String getRemoteAddr(); @Override String getRemoteHost(); @Override int getRemotePort(); @Override String getLocalAddr(); @Override int getLocalPort(); @Override String getHeader(String name); @Override Enumeration<String> getHeaders(String name); @Override Enumeration<String> getHeaderNames(); @Override int getIntHeader(String name); @Override String getMethod(); @Override String getPathInfo(); @Override String getQueryString(); @Override String getRequestURI(); @Override String getServletPath(); @Override String getContextPath(); @Override ServletInputStream getInputStream(); @Override AsyncContext getAsyncContext(); @Override Part getPart(String name); @Override Collection<Part> getParts(); RoutingContext getContext(); @Override String getCharacterEncoding(); }
@Test public void setParameter() { Map<String, String[]> parameterMap = new HashMap<>(); Deencapsulation.setField(request, "parameterMap", parameterMap); request.setParameter("k1", "v1"); request.setParameter("k2", "v2"); Assert.assertEquals("v1", request.getParameter("k1")); Assert.assertEquals("v2", request.getParameter("k2")); Assert.assertSame(parameterMap, request.getParameterMap()); Assert.assertThat(Collections.list(request.getParameterNames()), Matchers.contains("k1", "k2")); }
ReadStreamPart extends AbstractPart { public CompletableFuture<Void> saveToWriteStream(WriteStream<Buffer> writeStream) { return new PumpCommon().pump(context, readStream, writeStream, null); } ReadStreamPart(Context context, HttpClientResponse httpClientResponse); ReadStreamPart(Context context, ReadStream<Buffer> readStream); Context getContext(); ReadStream<Buffer> getReadStream(); CompletableFuture<Void> saveToWriteStream(WriteStream<Buffer> writeStream); CompletableFuture<byte[]> saveAsBytes(); CompletableFuture<String> saveAsString(); CompletableFuture<T> saveAs(Function<Buffer, T> converter); CompletableFuture<File> saveToFile(String fileName); CompletableFuture<File> saveToFile(File file, OpenOptions openOptions); }
@Test public void saveToWriteStream() throws InterruptedException, ExecutionException { Buffer buf = Buffer.buffer(); WriteStream<Buffer> writeStream = new MockUp<WriteStream<Buffer>>() { @Mock WriteStream<Buffer> write(Buffer data) { buf.appendBuffer(data); return null; } }.getMockInstance(); part.saveToWriteStream(writeStream).get(); Assert.assertEquals(src, buf.toString()); } @Test public void saveToWriteStream_writeException() throws InterruptedException, ExecutionException { RuntimeException error = new RuntimeExceptionWithoutStackTrace(); WriteStream<Buffer> writeStream = new MockUp<WriteStream<Buffer>>() { Handler<Throwable> exceptionHandler; @Mock WriteStream<Buffer> exceptionHandler(Handler<Throwable> handler) { this.exceptionHandler = handler; return null; } @Mock WriteStream<Buffer> write(Buffer data) { exceptionHandler.handle(error); return null; } }.getMockInstance(); expectedException.expect(ExecutionException.class); expectedException.expectCause(Matchers.sameInstance(error)); part.saveToWriteStream(writeStream).get(); } @Test public void saveToWrite_readException(@Mocked WriteStream<Buffer> writeStream) throws InterruptedException, ExecutionException { RuntimeException error = new RuntimeExceptionWithoutStackTrace(); new MockUp<InputStream>(inputStream) { @Mock int read(byte b[]) throws IOException { throw error; } }; expectedException.expect(ExecutionException.class); expectedException.expectCause(Matchers.sameInstance(error)); part.saveToWriteStream(writeStream).get(); }
ReadStreamPart extends AbstractPart { public CompletableFuture<byte[]> saveAsBytes() { return saveAs(buf -> buf.getBytes()); } ReadStreamPart(Context context, HttpClientResponse httpClientResponse); ReadStreamPart(Context context, ReadStream<Buffer> readStream); Context getContext(); ReadStream<Buffer> getReadStream(); CompletableFuture<Void> saveToWriteStream(WriteStream<Buffer> writeStream); CompletableFuture<byte[]> saveAsBytes(); CompletableFuture<String> saveAsString(); CompletableFuture<T> saveAs(Function<Buffer, T> converter); CompletableFuture<File> saveToFile(String fileName); CompletableFuture<File> saveToFile(File file, OpenOptions openOptions); }
@Test public void saveAsBytes() throws InterruptedException, ExecutionException { Assert.assertArrayEquals(src.getBytes(), part.saveAsBytes().get()); }
ReadStreamPart extends AbstractPart { public CompletableFuture<String> saveAsString() { return saveAs(buf -> buf.toString()); } ReadStreamPart(Context context, HttpClientResponse httpClientResponse); ReadStreamPart(Context context, ReadStream<Buffer> readStream); Context getContext(); ReadStream<Buffer> getReadStream(); CompletableFuture<Void> saveToWriteStream(WriteStream<Buffer> writeStream); CompletableFuture<byte[]> saveAsBytes(); CompletableFuture<String> saveAsString(); CompletableFuture<T> saveAs(Function<Buffer, T> converter); CompletableFuture<File> saveToFile(String fileName); CompletableFuture<File> saveToFile(File file, OpenOptions openOptions); }
@Test public void saveAsString() throws InterruptedException, ExecutionException { Assert.assertEquals(src, part.saveAsString().get()); }
ReadStreamPart extends AbstractPart { public CompletableFuture<File> saveToFile(String fileName) { File file = new File(fileName); file.getParentFile().mkdirs(); OpenOptions openOptions = new OpenOptions().setCreateNew(true); return saveToFile(file, openOptions); } ReadStreamPart(Context context, HttpClientResponse httpClientResponse); ReadStreamPart(Context context, ReadStream<Buffer> readStream); Context getContext(); ReadStream<Buffer> getReadStream(); CompletableFuture<Void> saveToWriteStream(WriteStream<Buffer> writeStream); CompletableFuture<byte[]> saveAsBytes(); CompletableFuture<String> saveAsString(); CompletableFuture<T> saveAs(Function<Buffer, T> converter); CompletableFuture<File> saveToFile(String fileName); CompletableFuture<File> saveToFile(File file, OpenOptions openOptions); }
@Test public void saveToFile() throws InterruptedException, ExecutionException, IOException { File dir = new File("target/notExist-" + UUID.randomUUID().toString()); File file = new File(dir, "a.txt"); Assert.assertFalse(dir.exists()); part.saveToFile(file.getAbsolutePath()).get(); Assert.assertEquals(src, FileUtils.readFileToString(file, StandardCharsets.UTF_8)); FileUtils.forceDelete(dir); Assert.assertFalse(dir.exists()); } @Test public void saveToFile_notExist_notCreate() throws InterruptedException, ExecutionException, IOException { File dir = new File("target/notExist-" + UUID.randomUUID().toString()); File file = new File(dir, "a.txt"); Assert.assertFalse(dir.exists()); expectedException.expect(ExecutionException.class); expectedException.expectCause(Matchers.instanceOf(FileSystemException.class)); OpenOptions openOptions = new OpenOptions().setCreateNew(false); part.saveToFile(file, openOptions).get(); }
StandardHttpServletResponseEx extends HttpServletResponseWrapper implements HttpServletResponseEx { @Override public void setBodyBuffer(Buffer bodyBuffer) { this.bodyBuffer.setBodyBuffer(bodyBuffer); } StandardHttpServletResponseEx(HttpServletResponse response); @Override void setBodyBuffer(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override byte[] getBodyBytes(); @Override int getBodyBytesLength(); @SuppressWarnings("deprecation") @Override void setStatus(int sc, String sm); @Override int getStatus(); @Override StatusType getStatusType(); @Override void flushBuffer(); @Override void setAttribute(String key, Object value); @Override Object getAttribute(String key); @Override CompletableFuture<Void> sendPart(Part part); }
@Test public void setBodyBuffer() { Assert.assertNull(responseEx.getBodyBuffer()); Buffer bodyBuffer = Buffer.buffer(); bodyBuffer.appendString("abc"); responseEx.setBodyBuffer(bodyBuffer); Assert.assertEquals("abc", responseEx.getBodyBuffer().toString()); }
StandardHttpServletResponseEx extends HttpServletResponseWrapper implements HttpServletResponseEx { @Override public byte[] getBodyBytes() { return bodyBuffer.getBodyBytes(); } StandardHttpServletResponseEx(HttpServletResponse response); @Override void setBodyBuffer(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override byte[] getBodyBytes(); @Override int getBodyBytesLength(); @SuppressWarnings("deprecation") @Override void setStatus(int sc, String sm); @Override int getStatus(); @Override StatusType getStatusType(); @Override void flushBuffer(); @Override void setAttribute(String key, Object value); @Override Object getAttribute(String key); @Override CompletableFuture<Void> sendPart(Part part); }
@Test public void getBodyBytes() { Buffer bodyBuffer = Buffer.buffer(); bodyBuffer.appendString("abc"); responseEx.setBodyBuffer(bodyBuffer); Assert.assertEquals("abc", new String(responseEx.getBodyBytes(), 0, responseEx.getBodyBytesLength())); }
StandardHttpServletResponseEx extends HttpServletResponseWrapper implements HttpServletResponseEx { @Override public int getBodyBytesLength() { return bodyBuffer.getBodyBytesLength(); } StandardHttpServletResponseEx(HttpServletResponse response); @Override void setBodyBuffer(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override byte[] getBodyBytes(); @Override int getBodyBytesLength(); @SuppressWarnings("deprecation") @Override void setStatus(int sc, String sm); @Override int getStatus(); @Override StatusType getStatusType(); @Override void flushBuffer(); @Override void setAttribute(String key, Object value); @Override Object getAttribute(String key); @Override CompletableFuture<Void> sendPart(Part part); }
@Test public void getBodyBytesLength() { Buffer bodyBuffer = Buffer.buffer(); bodyBuffer.appendString("abc"); responseEx.setBodyBuffer(bodyBuffer); Assert.assertEquals(3, responseEx.getBodyBytesLength()); }
ServiceCenterTask implements Runnable { @VisibleForTesting public boolean getSafeMode() { return safeMode; } ServiceCenterTask(EventBus eventBus, int interval, int checkTimes, MicroserviceServiceCenterTask microserviceServiceCenterTask); @Subscribe void onRegisterTask(AbstractRegisterTask task); @Subscribe void onMicroserviceInstanceHeartbeatTask(MicroserviceInstanceHeartbeatTask task); @Subscribe void onExceptionEvent(ExceptionEvent event); void init(); @Override void run(); @VisibleForTesting boolean getSafeMode(); }
@Test public void testSafeMode(@Mocked MicroserviceInstanceHeartbeatTask succeededTask, @Mocked MicroserviceInstanceHeartbeatTask failedTask) { new Expectations() { { succeededTask.getHeartbeatResult(); result = HeartbeatResult.SUCCESS; failedTask.getHeartbeatResult(); result = HeartbeatResult.DISCONNECTED; } }; Holder<Integer> count = new Holder<>(0); EventListener eventListener = new EventListener() { @Subscribe public void onModeChanged(SafeModeChangeEvent modeChangeEvent) { count.value++; } }; eventBus.register(eventListener); Assert.assertEquals(0, count.value.intValue()); eventBus.post(failedTask); eventBus.post(failedTask); eventBus.post(failedTask); Assert.assertEquals(0, count.value.intValue()); Assert.assertFalse(serviceCenterTask.getSafeMode()); eventBus.post(failedTask); Assert.assertEquals(1, count.value.intValue()); Assert.assertTrue(serviceCenterTask.getSafeMode()); eventBus.post(succeededTask); eventBus.post(succeededTask); eventBus.post(succeededTask); Assert.assertTrue(serviceCenterTask.getSafeMode()); Assert.assertEquals(1, count.value.intValue()); eventBus.post(succeededTask); Assert.assertFalse(serviceCenterTask.getSafeMode()); Assert.assertEquals(2, count.value.intValue()); eventBus.unregister(eventListener); }
StandardHttpServletResponseEx extends HttpServletResponseWrapper implements HttpServletResponseEx { @SuppressWarnings("deprecation") @Override public void setStatus(int sc, String sm) { super.setStatus(sc, sm); statusType = new HttpStatus(sc, sm); } StandardHttpServletResponseEx(HttpServletResponse response); @Override void setBodyBuffer(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override byte[] getBodyBytes(); @Override int getBodyBytesLength(); @SuppressWarnings("deprecation") @Override void setStatus(int sc, String sm); @Override int getStatus(); @Override StatusType getStatusType(); @Override void flushBuffer(); @Override void setAttribute(String key, Object value); @Override Object getAttribute(String key); @Override CompletableFuture<Void> sendPart(Part part); }
@Test public void setStatus() { responseEx.setStatus(200, "ok"); Assert.assertEquals(200, responseEx.getStatus()); Assert.assertEquals(200, responseEx.getStatusType().getStatusCode()); Assert.assertEquals("ok", responseEx.getStatusType().getReasonPhrase()); }
StandardHttpServletResponseEx extends HttpServletResponseWrapper implements HttpServletResponseEx { @Override public void flushBuffer() throws IOException { byte[] bytes = getBodyBytes(); if (bytes != null) { getOutputStream().write(bytes, 0, getBodyBytesLength()); } super.flushBuffer(); } StandardHttpServletResponseEx(HttpServletResponse response); @Override void setBodyBuffer(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override byte[] getBodyBytes(); @Override int getBodyBytesLength(); @SuppressWarnings("deprecation") @Override void setStatus(int sc, String sm); @Override int getStatus(); @Override StatusType getStatusType(); @Override void flushBuffer(); @Override void setAttribute(String key, Object value); @Override Object getAttribute(String key); @Override CompletableFuture<Void> sendPart(Part part); }
@Test public void flushBuffer() throws IOException { Buffer buffer = Buffer.buffer(); ServletOutputStream output = new ServletOutputStream() { @Override public boolean isReady() { return true; } @Override public void setWriteListener(WriteListener writeListener) { } @Override public void write(int b) throws IOException { buffer.appendByte((byte) b); } }; response = new MockUp<HttpServletResponse>() { @Mock ServletOutputStream getOutputStream() { return output; } }.getMockInstance(); responseEx = new StandardHttpServletResponseEx(response); responseEx.flushBuffer(); Assert.assertEquals(0, buffer.length()); Buffer body = Buffer.buffer().appendString("body"); responseEx.setBodyBuffer(body); responseEx.flushBuffer(); Assert.assertEquals("body", buffer.toString()); }
StandardHttpServletResponseEx extends HttpServletResponseWrapper implements HttpServletResponseEx { @Override public CompletableFuture<Void> sendPart(Part part) { DownloadUtils.prepareDownloadHeader(this, part); OutputStream outputStream; try { outputStream = getOutputStream(); } catch (IOException e) { CompletableFuture<Void> future = new CompletableFuture<>(); future.completeExceptionally(e); return future; } Context context = Vertx.currentContext(); return new PumpFromPart(context, part).toOutputStream(outputStream, false); } StandardHttpServletResponseEx(HttpServletResponse response); @Override void setBodyBuffer(Buffer bodyBuffer); @Override Buffer getBodyBuffer(); @Override byte[] getBodyBytes(); @Override int getBodyBytesLength(); @SuppressWarnings("deprecation") @Override void setStatus(int sc, String sm); @Override int getStatus(); @Override StatusType getStatusType(); @Override void flushBuffer(); @Override void setAttribute(String key, Object value); @Override Object getAttribute(String key); @Override CompletableFuture<Void> sendPart(Part part); }
@Test public void sendPart_succ() throws Throwable { String src = RandomStringUtils.random(100); InputStream inputStream = new ByteArrayInputStream(src.getBytes()); Part part = new InputStreamPart("name", inputStream); Buffer buffer = Buffer.buffer(); ServletOutputStream outputStream = new MockUp<ServletOutputStream>() { @Mock void write(int b) { buffer.appendByte((byte) b); } }.getMockInstance(); new Expectations() { { response.getOutputStream(); result = outputStream; } }; responseEx.sendPart(part).get(); Assert.assertEquals(src, buffer.toString()); } @Test public void sendPart_failed(@Mocked Part part) throws Throwable { RuntimeException error = new RuntimeExceptionWithoutStackTrace(); new Expectations() { { response.getOutputStream(); result = error; } }; expectedException.expect(Matchers.sameInstance(error)); responseEx.sendPart(part).get(); }
DefaultHttpServerMetrics implements HttpServerMetrics<Object, Object, DefaultHttpSocketMetric> { public DefaultServerEndpointMetric getEndpointMetric() { return endpointMetric; } DefaultHttpServerMetrics(DefaultServerEndpointMetric endpointMetric); DefaultServerEndpointMetric getEndpointMetric(); @Override Object requestBegin(DefaultHttpSocketMetric socketMetric, HttpServerRequest request); @Override void requestReset(Object requestMetric); @Override Object responsePushed(DefaultHttpSocketMetric socketMetric, HttpMethod method, String uri, HttpServerResponse response); @Override void responseEnd(Object requestMetric, HttpServerResponse response); @Override Object connected(DefaultHttpSocketMetric socketMetric, Object requestMetric, ServerWebSocket serverWebSocket); @Override void disconnected(Object serverWebSocketMetric); @Override DefaultHttpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void createMetrics() { Map<Object, Object> instances = new IdentityHashMap<>(); instances.put(metrics_listen1_server1, null); instances.put(metrics_listen1_server2, null); instances.put(metrics_listen2_server1, null); instances.put(metrics_listen2_server2, null); Assert.assertEquals(4, instances.size()); Assert.assertSame(metrics_listen1_server1.getEndpointMetric(), metrics_listen1_server2.getEndpointMetric()); Assert.assertNotSame(metrics_listen1_server1.getEndpointMetric(), metrics_listen2_server1.getEndpointMetric()); Assert.assertSame(metrics_listen2_server1.getEndpointMetric(), metrics_listen2_server2.getEndpointMetric()); }
DefaultHttpServerMetrics implements HttpServerMetrics<Object, Object, DefaultHttpSocketMetric> { @Override public void disconnected(Object serverWebSocketMetric) { } DefaultHttpServerMetrics(DefaultServerEndpointMetric endpointMetric); DefaultServerEndpointMetric getEndpointMetric(); @Override Object requestBegin(DefaultHttpSocketMetric socketMetric, HttpServerRequest request); @Override void requestReset(Object requestMetric); @Override Object responsePushed(DefaultHttpSocketMetric socketMetric, HttpMethod method, String uri, HttpServerResponse response); @Override void responseEnd(Object requestMetric, HttpServerResponse response); @Override Object connected(DefaultHttpSocketMetric socketMetric, Object requestMetric, ServerWebSocket serverWebSocket); @Override void disconnected(Object serverWebSocketMetric); @Override DefaultHttpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void connectionCount() { Map<Object, Object> instances = new IdentityHashMap<>(); instances.put(socketMetric_listen1_1, null); instances.put(socketMetric_listen1_2, null); instances.put(socketMetric_listen2_1, null); instances.put(socketMetric_listen2_2, null); instances.put(socketMetric_listen2_3, null); Assert.assertEquals(5, instances.size()); Assert.assertTrue(socketMetric_listen1_1.isConnected()); Assert.assertTrue(socketMetric_listen1_2.isConnected()); Assert.assertTrue(socketMetric_listen2_1.isConnected()); Assert.assertTrue(socketMetric_listen2_2.isConnected()); Assert.assertTrue(socketMetric_listen2_3.isConnected()); Assert.assertEquals(2, endpointMetric1.getCurrentConnectionCount()); Assert.assertEquals(3, endpointMetric2.getCurrentConnectionCount()); metrics_listen1_server1.disconnected(socketMetric_listen1_1, anyRemoteAddr); metrics_listen1_server2.disconnected(socketMetric_listen1_2, anyRemoteAddr); metrics_listen2_server1.disconnected(socketMetric_listen2_1, anyRemoteAddr); metrics_listen2_server2.disconnected(socketMetric_listen2_2, anyRemoteAddr); metrics_listen2_server2.disconnected(socketMetric_listen2_3, anyRemoteAddr); Assert.assertFalse(socketMetric_listen1_1.isConnected()); Assert.assertFalse(socketMetric_listen1_2.isConnected()); Assert.assertFalse(socketMetric_listen2_1.isConnected()); Assert.assertFalse(socketMetric_listen2_2.isConnected()); Assert.assertFalse(socketMetric_listen2_3.isConnected()); Assert.assertEquals(0, endpointMetric1.getCurrentConnectionCount()); Assert.assertEquals(0, endpointMetric2.getCurrentConnectionCount()); }
DefaultHttpServerMetrics implements HttpServerMetrics<Object, Object, DefaultHttpSocketMetric> { @Override public void bytesRead(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes) { endpointMetric.addBytesRead(numberOfBytes); } DefaultHttpServerMetrics(DefaultServerEndpointMetric endpointMetric); DefaultServerEndpointMetric getEndpointMetric(); @Override Object requestBegin(DefaultHttpSocketMetric socketMetric, HttpServerRequest request); @Override void requestReset(Object requestMetric); @Override Object responsePushed(DefaultHttpSocketMetric socketMetric, HttpMethod method, String uri, HttpServerResponse response); @Override void responseEnd(Object requestMetric, HttpServerResponse response); @Override Object connected(DefaultHttpSocketMetric socketMetric, Object requestMetric, ServerWebSocket serverWebSocket); @Override void disconnected(Object serverWebSocketMetric); @Override DefaultHttpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void bytesRead() { metrics_listen1_server1.bytesRead(socketMetric_listen1_1, anyRemoteAddr, 1); metrics_listen1_server2.bytesRead(socketMetric_listen1_2, anyRemoteAddr, 2); metrics_listen2_server1.bytesRead(socketMetric_listen2_1, anyRemoteAddr, 3); metrics_listen2_server2.bytesRead(socketMetric_listen2_2, anyRemoteAddr, 4); metrics_listen2_server2.bytesRead(socketMetric_listen2_3, anyRemoteAddr, 5); Assert.assertEquals(3, endpointMetric1.getBytesRead()); Assert.assertEquals(12, endpointMetric2.getBytesRead()); }
DefaultHttpServerMetrics implements HttpServerMetrics<Object, Object, DefaultHttpSocketMetric> { @Override public void bytesWritten(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes) { endpointMetric.addBytesWritten(numberOfBytes); } DefaultHttpServerMetrics(DefaultServerEndpointMetric endpointMetric); DefaultServerEndpointMetric getEndpointMetric(); @Override Object requestBegin(DefaultHttpSocketMetric socketMetric, HttpServerRequest request); @Override void requestReset(Object requestMetric); @Override Object responsePushed(DefaultHttpSocketMetric socketMetric, HttpMethod method, String uri, HttpServerResponse response); @Override void responseEnd(Object requestMetric, HttpServerResponse response); @Override Object connected(DefaultHttpSocketMetric socketMetric, Object requestMetric, ServerWebSocket serverWebSocket); @Override void disconnected(Object serverWebSocketMetric); @Override DefaultHttpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void bytesWritten() { metrics_listen1_server1.bytesWritten(socketMetric_listen1_1, anyRemoteAddr, 1); metrics_listen1_server2.bytesWritten(socketMetric_listen1_2, anyRemoteAddr, 2); metrics_listen2_server1.bytesWritten(socketMetric_listen2_1, anyRemoteAddr, 3); metrics_listen2_server2.bytesWritten(socketMetric_listen2_2, anyRemoteAddr, 4); metrics_listen2_server2.bytesWritten(socketMetric_listen2_3, anyRemoteAddr, 5); Assert.assertEquals(3, endpointMetric1.getBytesWritten()); Assert.assertEquals(12, endpointMetric2.getBytesWritten()); }
DefaultTcpServerMetrics implements TCPMetrics<DefaultTcpSocketMetric> { public DefaultServerEndpointMetric getEndpointMetric() { return endpointMetric; } DefaultTcpServerMetrics(DefaultServerEndpointMetric endpointMetric); DefaultServerEndpointMetric getEndpointMetric(); @Override DefaultTcpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void createMetrics() { Map<Object, Object> instances = new IdentityHashMap<>(); instances.put(metrics_listen1_server1, null); instances.put(metrics_listen1_server2, null); instances.put(metrics_listen2_server1, null); instances.put(metrics_listen2_server2, null); Assert.assertEquals(4, instances.size()); Assert.assertSame(metrics_listen1_server1.getEndpointMetric(), metrics_listen1_server2.getEndpointMetric()); Assert.assertNotSame(metrics_listen1_server1.getEndpointMetric(), metrics_listen2_server1.getEndpointMetric()); Assert.assertSame(metrics_listen2_server1.getEndpointMetric(), metrics_listen2_server2.getEndpointMetric()); }
DefaultTcpServerMetrics implements TCPMetrics<DefaultTcpSocketMetric> { @Override public void disconnected(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress) { socketMetric.onDisconnect(); } DefaultTcpServerMetrics(DefaultServerEndpointMetric endpointMetric); DefaultServerEndpointMetric getEndpointMetric(); @Override DefaultTcpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void connectionCount() { Map<Object, Object> instances = new IdentityHashMap<>(); instances.put(socketMetric_listen1_1, null); instances.put(socketMetric_listen1_2, null); instances.put(socketMetric_listen2_1, null); instances.put(socketMetric_listen2_2, null); instances.put(socketMetric_listen2_3, null); Assert.assertEquals(5, instances.size()); Assert.assertTrue(socketMetric_listen1_1.isConnected()); Assert.assertTrue(socketMetric_listen1_2.isConnected()); Assert.assertTrue(socketMetric_listen2_1.isConnected()); Assert.assertTrue(socketMetric_listen2_2.isConnected()); Assert.assertTrue(socketMetric_listen2_3.isConnected()); Assert.assertEquals(2, endpointMetric1.getCurrentConnectionCount()); Assert.assertEquals(3, endpointMetric2.getCurrentConnectionCount()); metrics_listen1_server1.disconnected(socketMetric_listen1_1, anyRemoteAddr); metrics_listen1_server2.disconnected(socketMetric_listen1_2, anyRemoteAddr); metrics_listen2_server1.disconnected(socketMetric_listen2_1, anyRemoteAddr); metrics_listen2_server2.disconnected(socketMetric_listen2_2, anyRemoteAddr); metrics_listen2_server2.disconnected(socketMetric_listen2_3, anyRemoteAddr); Assert.assertFalse(socketMetric_listen1_1.isConnected()); Assert.assertFalse(socketMetric_listen1_2.isConnected()); Assert.assertFalse(socketMetric_listen2_1.isConnected()); Assert.assertFalse(socketMetric_listen2_2.isConnected()); Assert.assertFalse(socketMetric_listen2_3.isConnected()); Assert.assertEquals(0, endpointMetric1.getCurrentConnectionCount()); Assert.assertEquals(0, endpointMetric2.getCurrentConnectionCount()); }
CompositeTask implements Runnable { public void run() { for (Runnable task : taskList) { task.run(); } } void addTask(Runnable task); int getTaskCount(); void run(); }
@Test public void testRun() { CompositeTask task = new CompositeTask(); for (int idx = 0; idx < 3; idx++) { task.addTask(() -> { count++; }); } task.run(); Assert.assertEquals(3, count); Assert.assertEquals(3, task.getTaskCount()); }
DefaultTcpServerMetrics implements TCPMetrics<DefaultTcpSocketMetric> { @Override public void bytesRead(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes) { endpointMetric.addBytesRead(numberOfBytes); } DefaultTcpServerMetrics(DefaultServerEndpointMetric endpointMetric); DefaultServerEndpointMetric getEndpointMetric(); @Override DefaultTcpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void bytesRead() { metrics_listen1_server1.bytesRead(socketMetric_listen1_1, anyRemoteAddr, 1); metrics_listen1_server2.bytesRead(socketMetric_listen1_2, anyRemoteAddr, 2); metrics_listen2_server1.bytesRead(socketMetric_listen2_1, anyRemoteAddr, 3); metrics_listen2_server2.bytesRead(socketMetric_listen2_2, anyRemoteAddr, 4); metrics_listen2_server2.bytesRead(socketMetric_listen2_3, anyRemoteAddr, 5); Assert.assertEquals(3, endpointMetric1.getBytesRead()); Assert.assertEquals(12, endpointMetric2.getBytesRead()); }
DefaultTcpServerMetrics implements TCPMetrics<DefaultTcpSocketMetric> { @Override public void bytesWritten(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes) { endpointMetric.addBytesWritten(numberOfBytes); } DefaultTcpServerMetrics(DefaultServerEndpointMetric endpointMetric); DefaultServerEndpointMetric getEndpointMetric(); @Override DefaultTcpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void bytesWritten() { metrics_listen1_server1.bytesWritten(socketMetric_listen1_1, anyRemoteAddr, 1); metrics_listen1_server2.bytesWritten(socketMetric_listen1_2, anyRemoteAddr, 2); metrics_listen2_server1.bytesWritten(socketMetric_listen2_1, anyRemoteAddr, 3); metrics_listen2_server2.bytesWritten(socketMetric_listen2_2, anyRemoteAddr, 4); metrics_listen2_server2.bytesWritten(socketMetric_listen2_3, anyRemoteAddr, 5); Assert.assertEquals(3, endpointMetric1.getBytesWritten()); Assert.assertEquals(12, endpointMetric2.getBytesWritten()); }
DefaultHttpClientMetrics implements HttpClientMetrics<DefaultHttpSocketMetric, Object, DefaultHttpSocketMetric, DefaultClientEndpointMetric, Object> { @Override public DefaultClientEndpointMetric createEndpoint(String host, int port, int maxPoolSize) { return this.clientEndpointMetricManager.getOrCreateEndpointMetric(host + ":" + port); } DefaultHttpClientMetrics(DefaultClientEndpointMetricManager clientEndpointMetricManager); @Override DefaultClientEndpointMetric createEndpoint(String host, int port, int maxPoolSize); @Override void closeEndpoint(String host, int port, DefaultClientEndpointMetric endpointMetric); @Override Object enqueueRequest(DefaultClientEndpointMetric endpointMetric); @Override void dequeueRequest(DefaultClientEndpointMetric endpointMetric, Object taskMetric); @Override void endpointConnected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric); @Override void endpointDisconnected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric); @Override DefaultHttpSocketMetric requestBegin(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, SocketAddress localAddress, SocketAddress remoteAddress, HttpClientRequest request); @Override void requestEnd(DefaultHttpSocketMetric requestMetric); @Override void responseBegin(DefaultHttpSocketMetric requestMetric, HttpClientResponse response); @Override DefaultHttpSocketMetric responsePushed(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, SocketAddress localAddress, SocketAddress remoteAddress, HttpClientRequest request); @Override void requestReset(DefaultHttpSocketMetric requestMetric); @Override void responseEnd(DefaultHttpSocketMetric requestMetric, HttpClientResponse response); @Override Object connected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, WebSocket webSocket); @Override void disconnected(Object webSocketMetric); @Override DefaultHttpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void createEndpoint() { Assert.assertSame(endpointMetric_a_1, endpointMetric_b_1); Assert.assertNotSame(endpointMetric_a_1, endpointMetric_a_2); Assert.assertNotSame(endpointMetric_a_2, endpointMetric_b_1); Assert.assertSame(endpointMetric_a_2, endpointMetric_b_2); Assert.assertEquals(2, endpointMetric_a_1.getCurrentConnectionCount()); Assert.assertEquals(2, endpointMetric_a_2.getCurrentConnectionCount()); }
DefaultHttpClientMetrics implements HttpClientMetrics<DefaultHttpSocketMetric, Object, DefaultHttpSocketMetric, DefaultClientEndpointMetric, Object> { @Override public void disconnected(Object webSocketMetric) { } DefaultHttpClientMetrics(DefaultClientEndpointMetricManager clientEndpointMetricManager); @Override DefaultClientEndpointMetric createEndpoint(String host, int port, int maxPoolSize); @Override void closeEndpoint(String host, int port, DefaultClientEndpointMetric endpointMetric); @Override Object enqueueRequest(DefaultClientEndpointMetric endpointMetric); @Override void dequeueRequest(DefaultClientEndpointMetric endpointMetric, Object taskMetric); @Override void endpointConnected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric); @Override void endpointDisconnected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric); @Override DefaultHttpSocketMetric requestBegin(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, SocketAddress localAddress, SocketAddress remoteAddress, HttpClientRequest request); @Override void requestEnd(DefaultHttpSocketMetric requestMetric); @Override void responseBegin(DefaultHttpSocketMetric requestMetric, HttpClientResponse response); @Override DefaultHttpSocketMetric responsePushed(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, SocketAddress localAddress, SocketAddress remoteAddress, HttpClientRequest request); @Override void requestReset(DefaultHttpSocketMetric requestMetric); @Override void responseEnd(DefaultHttpSocketMetric requestMetric, HttpClientResponse response); @Override Object connected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, WebSocket webSocket); @Override void disconnected(Object webSocketMetric); @Override DefaultHttpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void expire() { metricsOptionsEx.setCheckClientEndpointMetricExpiredInNano(10); nanoTime = 2; clientMetrics_a.disconnected(socketMetric_a_1, null); clientMetrics_a.disconnected(socketMetric_a_2, null); nanoTime = 13; defaultVertxMetrics.getClientEndpointMetricManager().onCheckClientEndpointMetricExpired(0); Assert.assertNotNull( defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address1.toString())); Assert.assertNotNull( defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address2.toString())); clientMetrics_b.disconnected(socketMetric_b_1, null); clientMetrics_b.disconnected(socketMetric_b_2, null); nanoTime = 23; defaultVertxMetrics.getClientEndpointMetricManager().onCheckClientEndpointMetricExpired(0); Assert.assertNotNull( defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address1.toString())); Assert.assertNotNull( defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address2.toString())); nanoTime = 24; defaultVertxMetrics.getClientEndpointMetricManager().onCheckClientEndpointMetricExpired(0); Assert .assertNull(defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address1.toString())); Assert .assertNull(defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address2.toString())); } @Test public void connect() { { Assert.assertSame(endpointMetric_a_1, socketMetric_a_1.getEndpointMetric()); Assert.assertTrue(socketMetric_a_1.isConnected()); Assert.assertEquals(1, socketMetric_a_1.getConnectedTime()); Assert.assertEquals(2, socketMetric_a_1.getEndpointMetric().getConnectCount()); Assert.assertEquals(0, socketMetric_a_1.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(2, socketMetric_a_1.getEndpointMetric().getCurrentConnectionCount()); nanoTime = 2; clientMetrics_a.disconnected(socketMetric_a_1, null); Assert.assertEquals(2, endpointMetric_a_1.getLastNanoTime()); Assert.assertFalse(socketMetric_a_1.isConnected()); Assert.assertEquals(1, socketMetric_a_1.getConnectedTime()); Assert.assertEquals(2, socketMetric_a_1.getEndpointMetric().getConnectCount()); Assert.assertEquals(1, socketMetric_a_1.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(1, socketMetric_a_1.getEndpointMetric().getCurrentConnectionCount()); } { Assert.assertSame(endpointMetric_a_2, socketMetric_a_2.getEndpointMetric()); Assert.assertTrue(socketMetric_a_2.isConnected()); Assert.assertEquals(1, socketMetric_a_2.getConnectedTime()); Assert.assertEquals(2, socketMetric_a_2.getEndpointMetric().getConnectCount()); Assert.assertEquals(0, socketMetric_a_2.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(2, socketMetric_a_2.getEndpointMetric().getCurrentConnectionCount()); nanoTime = 4; clientMetrics_a.disconnected(socketMetric_a_2, null); Assert.assertEquals(4, endpointMetric_a_2.getLastNanoTime()); Assert.assertFalse(socketMetric_a_2.isConnected()); Assert.assertEquals(1, socketMetric_a_2.getConnectedTime()); Assert.assertEquals(2, socketMetric_a_2.getEndpointMetric().getConnectCount()); Assert.assertEquals(1, socketMetric_a_2.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(1, socketMetric_a_2.getEndpointMetric().getCurrentConnectionCount()); } { Assert.assertSame(endpointMetric_b_1, socketMetric_b_1.getEndpointMetric()); Assert.assertTrue(socketMetric_b_1.isConnected()); Assert.assertEquals(1, socketMetric_b_1.getConnectedTime()); Assert.assertEquals(2, socketMetric_b_1.getEndpointMetric().getConnectCount()); Assert.assertEquals(1, socketMetric_b_1.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(1, socketMetric_b_1.getEndpointMetric().getCurrentConnectionCount()); nanoTime = 6; clientMetrics_b.disconnected(socketMetric_b_1, null); Assert.assertEquals(6, endpointMetric_b_1.getLastNanoTime()); Assert.assertFalse(socketMetric_b_1.isConnected()); Assert.assertEquals(1, socketMetric_b_1.getConnectedTime()); Assert.assertEquals(2, socketMetric_b_1.getEndpointMetric().getConnectCount()); Assert.assertEquals(2, socketMetric_b_1.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(0, socketMetric_b_1.getEndpointMetric().getCurrentConnectionCount()); } { Assert.assertSame(endpointMetric_b_2, socketMetric_b_2.getEndpointMetric()); Assert.assertTrue(socketMetric_b_2.isConnected()); Assert.assertEquals(1, socketMetric_b_2.getConnectedTime()); Assert.assertEquals(2, socketMetric_b_2.getEndpointMetric().getConnectCount()); Assert.assertEquals(1, socketMetric_b_2.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(1, socketMetric_b_2.getEndpointMetric().getCurrentConnectionCount()); nanoTime = 7; clientMetrics_b.disconnected(socketMetric_b_2, null); Assert.assertEquals(7, endpointMetric_b_2.getLastNanoTime()); Assert.assertFalse(socketMetric_b_2.isConnected()); Assert.assertEquals(1, socketMetric_b_2.getConnectedTime()); Assert.assertEquals(2, socketMetric_b_2.getEndpointMetric().getConnectCount()); Assert.assertEquals(2, socketMetric_b_2.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(0, socketMetric_b_2.getEndpointMetric().getCurrentConnectionCount()); } }
DefaultHttpClientMetrics implements HttpClientMetrics<DefaultHttpSocketMetric, Object, DefaultHttpSocketMetric, DefaultClientEndpointMetric, Object> { @Override public DefaultHttpSocketMetric requestBegin(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, SocketAddress localAddress, SocketAddress remoteAddress, HttpClientRequest request) { socketMetric.requestBegin(); return socketMetric; } DefaultHttpClientMetrics(DefaultClientEndpointMetricManager clientEndpointMetricManager); @Override DefaultClientEndpointMetric createEndpoint(String host, int port, int maxPoolSize); @Override void closeEndpoint(String host, int port, DefaultClientEndpointMetric endpointMetric); @Override Object enqueueRequest(DefaultClientEndpointMetric endpointMetric); @Override void dequeueRequest(DefaultClientEndpointMetric endpointMetric, Object taskMetric); @Override void endpointConnected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric); @Override void endpointDisconnected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric); @Override DefaultHttpSocketMetric requestBegin(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, SocketAddress localAddress, SocketAddress remoteAddress, HttpClientRequest request); @Override void requestEnd(DefaultHttpSocketMetric requestMetric); @Override void responseBegin(DefaultHttpSocketMetric requestMetric, HttpClientResponse response); @Override DefaultHttpSocketMetric responsePushed(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, SocketAddress localAddress, SocketAddress remoteAddress, HttpClientRequest request); @Override void requestReset(DefaultHttpSocketMetric requestMetric); @Override void responseEnd(DefaultHttpSocketMetric requestMetric, HttpClientResponse response); @Override Object connected(DefaultClientEndpointMetric endpointMetric, DefaultHttpSocketMetric socketMetric, WebSocket webSocket); @Override void disconnected(Object webSocketMetric); @Override DefaultHttpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultHttpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void requestBegin(@Mocked HttpClientRequest request) { DefaultHttpSocketMetric socketMetric = clientMetrics_a.connected(address1, host); nanoTime = 2; clientMetrics_a.requestBegin(endpointMetric_a_1, socketMetric, address1, address1, request); nanoTime = 3; clientMetrics_a.requestEnd(socketMetric); Assert.assertEquals(2, socketMetric.getRequestBeginTime()); Assert.assertEquals(3, socketMetric.getRequestEndTime()); }
DefaultVertxMetricsFactory implements VertxMetricsFactory { @Override public synchronized VertxMetrics metrics(VertxOptions options) { if (vertxMetrics == null) { vertxMetrics = new DefaultVertxMetrics(options); } return vertxMetrics; } DefaultVertxMetrics getVertxMetrics(); @Override synchronized VertxMetrics metrics(VertxOptions options); @Override MetricsOptions newOptions(); void setVertx(Vertx vertx, VertxOptions options); }
@SuppressWarnings("deprecation") @Test public void metrics() { MetricsOptions metricsOptions = factory.newOptions(); options.setMetricsOptions(metricsOptions); VertxMetrics vertxMetrics = factory.metrics(options); Assert.assertSame(factory, metricsOptions.getFactory()); Assert.assertTrue(metricsOptions.isEnabled()); Assert.assertSame(factory.getVertxMetrics(), vertxMetrics); Assert.assertTrue(vertxMetrics.isMetricsEnabled()); Assert.assertTrue(vertxMetrics.isEnabled()); }
DefaultTcpClientMetrics implements TCPMetrics<DefaultTcpSocketMetric> { @Override public void disconnected(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress) { socketMetric.onDisconnect(); } DefaultTcpClientMetrics(DefaultClientEndpointMetricManager clientEndpointMetricManager); @Override DefaultTcpSocketMetric connected(SocketAddress remoteAddress, String remoteName); @Override void disconnected(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress); @Override void bytesRead(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void bytesWritten(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, long numberOfBytes); @Override void exceptionOccurred(DefaultTcpSocketMetric socketMetric, SocketAddress remoteAddress, Throwable t); @Override @Deprecated boolean isEnabled(); @Override void close(); }
@Test public void expire() { metricsOptionsEx.setCheckClientEndpointMetricExpiredInNano(10); nanoTime = 2; clientMetrics_a.disconnected(socketMetric_a_1, null); clientMetrics_a.disconnected(socketMetric_a_2, null); nanoTime = 13; defaultVertxMetrics.getClientEndpointMetricManager().onCheckClientEndpointMetricExpired(0); Assert.assertNotNull( defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address1.toString())); Assert.assertNotNull( defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address2.toString())); clientMetrics_b.disconnected(socketMetric_b_1, null); clientMetrics_b.disconnected(socketMetric_b_2, null); nanoTime = 23; defaultVertxMetrics.getClientEndpointMetricManager().onCheckClientEndpointMetricExpired(0); Assert.assertNotNull( defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address1.toString())); Assert.assertNotNull( defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address2.toString())); nanoTime = 24; defaultVertxMetrics.getClientEndpointMetricManager().onCheckClientEndpointMetricExpired(0); Assert .assertNull(defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address1.toString())); Assert .assertNull(defaultVertxMetrics.getClientEndpointMetricManager().getClientEndpointMetric(address2.toString())); } @Test public void connect() { { Assert.assertSame(endpointMetric_a_1, socketMetric_a_1.getEndpointMetric()); Assert.assertTrue(socketMetric_a_1.isConnected()); Assert.assertEquals(1, socketMetric_a_1.getConnectedTime()); Assert.assertEquals(2, socketMetric_a_1.getEndpointMetric().getConnectCount()); Assert.assertEquals(0, socketMetric_a_1.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(2, socketMetric_a_1.getEndpointMetric().getCurrentConnectionCount()); nanoTime = 2; clientMetrics_a.disconnected(socketMetric_a_1, null); Assert.assertEquals(2, endpointMetric_a_1.getLastNanoTime()); Assert.assertFalse(socketMetric_a_1.isConnected()); Assert.assertEquals(1, socketMetric_a_1.getConnectedTime()); Assert.assertEquals(2, socketMetric_a_1.getEndpointMetric().getConnectCount()); Assert.assertEquals(1, socketMetric_a_1.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(1, socketMetric_a_1.getEndpointMetric().getCurrentConnectionCount()); } { Assert.assertSame(endpointMetric_a_2, socketMetric_a_2.getEndpointMetric()); Assert.assertTrue(socketMetric_a_2.isConnected()); Assert.assertEquals(1, socketMetric_a_2.getConnectedTime()); Assert.assertEquals(2, socketMetric_a_2.getEndpointMetric().getConnectCount()); Assert.assertEquals(0, socketMetric_a_2.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(2, socketMetric_a_2.getEndpointMetric().getCurrentConnectionCount()); nanoTime = 4; clientMetrics_a.disconnected(socketMetric_a_2, null); Assert.assertEquals(4, endpointMetric_a_2.getLastNanoTime()); Assert.assertFalse(socketMetric_a_2.isConnected()); Assert.assertEquals(1, socketMetric_a_2.getConnectedTime()); Assert.assertEquals(2, socketMetric_a_2.getEndpointMetric().getConnectCount()); Assert.assertEquals(1, socketMetric_a_2.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(1, socketMetric_a_2.getEndpointMetric().getCurrentConnectionCount()); } { Assert.assertSame(endpointMetric_b_1, socketMetric_b_1.getEndpointMetric()); Assert.assertTrue(socketMetric_b_1.isConnected()); Assert.assertEquals(1, socketMetric_b_1.getConnectedTime()); Assert.assertEquals(2, socketMetric_b_1.getEndpointMetric().getConnectCount()); Assert.assertEquals(1, socketMetric_b_1.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(1, socketMetric_b_1.getEndpointMetric().getCurrentConnectionCount()); nanoTime = 6; clientMetrics_b.disconnected(socketMetric_b_1, null); Assert.assertEquals(6, endpointMetric_b_1.getLastNanoTime()); Assert.assertFalse(socketMetric_b_1.isConnected()); Assert.assertEquals(1, socketMetric_b_1.getConnectedTime()); Assert.assertEquals(2, socketMetric_b_1.getEndpointMetric().getConnectCount()); Assert.assertEquals(2, socketMetric_b_1.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(0, socketMetric_b_1.getEndpointMetric().getCurrentConnectionCount()); } { Assert.assertSame(endpointMetric_b_2, socketMetric_b_2.getEndpointMetric()); Assert.assertTrue(socketMetric_b_2.isConnected()); Assert.assertEquals(1, socketMetric_b_2.getConnectedTime()); Assert.assertEquals(2, socketMetric_b_2.getEndpointMetric().getConnectCount()); Assert.assertEquals(1, socketMetric_b_2.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(1, socketMetric_b_2.getEndpointMetric().getCurrentConnectionCount()); nanoTime = 7; clientMetrics_b.disconnected(socketMetric_b_2, null); Assert.assertEquals(7, endpointMetric_b_2.getLastNanoTime()); Assert.assertFalse(socketMetric_b_2.isConnected()); Assert.assertEquals(1, socketMetric_b_2.getConnectedTime()); Assert.assertEquals(2, socketMetric_b_2.getEndpointMetric().getConnectCount()); Assert.assertEquals(2, socketMetric_b_2.getEndpointMetric().getDisconnectCount()); Assert.assertEquals(0, socketMetric_b_2.getEndpointMetric().getCurrentConnectionCount()); } }
SharedVertxFactory { public static Vertx getSharedVertx() { return VertxUtils.getVertxMap().computeIfAbsent("transport", SharedVertxFactory::createSharedVertx); } static DefaultVertxMetricsFactory getMetricsFactory(); static Vertx getSharedVertx(); }
@Test public void getTransportVertx() { Assert.assertNotNull(SharedVertxFactory.getSharedVertx()); Assert.assertSame(SharedVertxFactory.getSharedVertx(), SharedVertxFactory.getSharedVertx()); SharedVertxFactory.getSharedVertx().close(); }
ServiceCombVersion implements Versions { @Override public Map<String, String> loadVersion() { Map<String, String> map = new HashMap<>(); map.put("ServiceComb", this.getClass().getPackage().getImplementationVersion()); return map; } @Override Map<String, String> loadVersion(); }
@Test public void testServiceCombVersion() { ServiceCombVersion version = new ServiceCombVersion(); Assert.assertTrue(version.loadVersion().toString().contains("ServiceComb")); }
VertxUtils { public static byte[] getBytesFast(InputStream inputStream) throws IOException { if (BufferInputStream.class.isInstance(inputStream)) { return getBytesFast(((BufferInputStream) inputStream).getByteBuf()); } return IOUtils.toByteArray(inputStream); } private VertxUtils(); static Map<String, Vertx> getVertxMap(); static void deployVerticle(Vertx vertx, Class<T> cls, int instanceCount); static DeploymentOptions createClientDeployOptions( ClientPoolManager<CLIENT_POOL> clientMgr, int instanceCount); static boolean blockDeploy(Vertx vertx, Class<VERTICLE> cls, DeploymentOptions options); static Vertx getOrCreateVertxByName(String name, VertxOptions vertxOptions); static Vertx init(VertxOptions vertxOptions); static Vertx init(String name, VertxOptions vertxOptions); static byte[] getBytesFast(InputStream inputStream); static byte[] getBytesFast(Buffer buffer); static byte[] getBytesFast(ByteBuf byteBuf); static CompletableFuture<Void> closeVertxByName(String name); static void blockCloseVertxByName(String name); static void blockCloseVertx(Vertx vertx); }
@Test public void testgetBytesFastBufferInputStream() throws IOException { byte[] bytes = new byte[] {1}; ByteBuf byteBuf = Unpooled.wrappedBuffer(bytes); try (BufferInputStream inputStream = new BufferInputStream(byteBuf)) { byte[] result = VertxUtils.getBytesFast(inputStream); Assert.assertSame(bytes, result); } } @Test public void testgetBytesFastNormalInputStream() throws IOException { byte[] bytes = new byte[] {1}; try (InputStream inputStream = new ByteArrayInputStream(bytes)) { byte[] result = VertxUtils.getBytesFast(inputStream); Assert.assertEquals(1, result[0]); } } @Test public void testgetBytesFastBuffer() { Buffer buffer = Buffer.buffer(); buffer.appendByte((byte) 1); byte[] result = VertxUtils.getBytesFast(buffer); Assert.assertEquals(1, result[0]); } @Test public void testgetBytesFastByteBufHasArray() { byte[] bytes = new byte[] {1}; ByteBuf byteBuf = Unpooled.wrappedBuffer(bytes); byte[] result = VertxUtils.getBytesFast(byteBuf); Assert.assertSame(bytes, result); } @Test public void testgetBytesFastByteBufCopy() { ByteBuf byteBuf = Unpooled.directBuffer(); byteBuf.writeByte(1); Assert.assertFalse(byteBuf.hasArray()); byte[] result = VertxUtils.getBytesFast(byteBuf); Assert.assertEquals(1, result[0]); byteBuf.release(); }
BufferInputStream extends ServletInputStream { @Override public int read() { return byteBuf.readUnsignedByte(); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testRead() { Assert.assertEquals(0, instance.read()); } @Test public void testReadByteArray() throws UnsupportedEncodingException { byte[] b = "csr".getBytes("UTF-8"); Assert.assertEquals(-1, instance.read(b)); } @Test public void testReadByteArrayIntInt() throws UnsupportedEncodingException { byte[] b = "csr".getBytes("UTF-8"); Assert.assertEquals(-1, instance.read(b, 1, 0)); }
BufferInputStream extends ServletInputStream { @Override public long skip(long len) { int skipLen = Math.min((int) len, available()); byteBuf.skipBytes(skipLen); return skipLen; } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testSkip() { Assert.assertEquals(0, instance.skip(1)); }
BufferInputStream extends ServletInputStream { @Override public int available() { return byteBuf.readableBytes(); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testAvailable() { Assert.assertEquals(0, instance.available()); }
RegisterInstanceRequest { public MicroserviceInstance getInstance() { return instance; } MicroserviceInstance getInstance(); void setInstance(MicroserviceInstance instance); }
@Test public void testDefaultValues() { Assert.assertNull(oRegisterInstanceRequest.getInstance()); } @Test public void testInitializedValues() { initRegisterInstanceRequest(); Assert.assertEquals(oMockMicroserviceInstance, oRegisterInstanceRequest.getInstance()); }
BufferInputStream extends ServletInputStream { @Override public void close() { byteBuf.release(); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testClose() { try { instance.close(); } catch (Exception e) { Assert.assertTrue(false); } }
BufferInputStream extends ServletInputStream { public BufferInputStream(ByteBuf buffer) { this.byteBuf = buffer; } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testBufferInputStream() { Assert.assertNotNull(instance); }
BufferInputStream extends ServletInputStream { public boolean readBoolean() { return byteBuf.readBoolean(); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testReadBoolean() { Assert.assertEquals(false, instance.readBoolean()); }
BufferInputStream extends ServletInputStream { public short readShort() { return byteBuf.readShort(); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testReadShort() { Assert.assertEquals(0, instance.readShort()); }
BufferInputStream extends ServletInputStream { public int readInt() { return byteBuf.readInt(); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testReadInt() { Assert.assertEquals(0, instance.readInt()); }
BufferInputStream extends ServletInputStream { public long readLong() { return byteBuf.readLong(); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testReadLong() { Assert.assertEquals(0, instance.readLong()); }
BufferInputStream extends ServletInputStream { public int getIndex() { return byteBuf.readerIndex(); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testGetIndex() { Assert.assertEquals(0, instance.getIndex()); }
BufferInputStream extends ServletInputStream { public String readString() { int length = readInt(); byte[] bytes = new byte[length]; byteBuf.readBytes(bytes); return new String(bytes, StandardCharsets.UTF_8); } BufferInputStream(ByteBuf buffer); @Override long skip(long len); byte readByte(); @Override int read(); boolean readBoolean(); short readShort(); int readInt(); long readLong(); int getIndex(); String readString(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override void close(); @Override void reset(); ByteBuf getByteBuf(); @Override boolean isFinished(); @Override boolean isReady(); @Override void setReadListener(ReadListener readListener); }
@Test public void testReadString() { Assert.assertNotNull(instance.readString()); }
AddressResolverConfig { public static AddressResolverOptions getAddressResover(String tag) { return getAddressResover(tag, null); } static AddressResolverOptions getAddressResover(String tag); static AddressResolverOptions getAddressResover(String tag, Configuration configSource); }
@Test public void testGetResoverFromResource(@Mocked Configuration finalConfig) { ArchaiusUtils.resetConfig(); ArchaiusUtils.setProperty("addressResolver.servers", "8.8.8.8,8.8.4.4"); new Expectations() { { finalConfig.getStringArray("addressResolver.servers"); result = new String[] {"6.6.6.6", "6.6.4.4"}; finalConfig.getStringArray("addressResolver.searchDomains"); result = new String[] {"default.svc.local.cluster"}; finalConfig.getInteger("addressResolver.queryTimeout", null); result = 2000; finalConfig.getInteger("addressResolver.maxQueries", null); result = -2; } }; AddressResolverOptions aroc = AddressResolverConfig.getAddressResover("test", finalConfig); Assert.assertThat(aroc.getServers(), is(Arrays.asList("6.6.6.6", "6.6.4.4"))); Assert.assertThat(aroc.getSearchDomains(), is(Arrays.asList("default.svc.local.cluster"))); Assert.assertEquals(aroc.getQueryTimeout(), 2000); Assert.assertNotEquals(aroc.getMaxQueries(), -2); } @Test public void testGetResover() { ArchaiusUtils.resetConfig(); ArchaiusUtils.setProperty("addressResolver.servers", "8.8.8.8,8.8.4.4"); ArchaiusUtils.setProperty("addressResolver.optResourceEnabled", true); ArchaiusUtils.setProperty("addressResolver.cacheMinTimeToLive", 0); ArchaiusUtils.setProperty("addressResolver.cacheMaxTimeToLive", 10000); ArchaiusUtils.setProperty("addressResolver.cacheNegativeTimeToLive", 0); ArchaiusUtils.setProperty("addressResolver.queryTimeout", 1000); ArchaiusUtils.setProperty("addressResolver.maxQueries", 3); ArchaiusUtils.setProperty("addressResolver.test.maxQueries", 3); ArchaiusUtils.setProperty("addressResolver.rdFlag", true); ArchaiusUtils.setProperty("addressResolver.searchDomains", "default.svc.local.cluster,svc.local.cluster,local.cluster"); ArchaiusUtils.setProperty("addressResolver.test.searchDomains", "test.svc.local.cluster,svc.local.cluster,local.cluster"); ArchaiusUtils.setProperty("addressResolver.ndots", 3); ArchaiusUtils.setProperty("addressResolver.rotateServers", true); AddressResolverOptions aroc = AddressResolverConfig.getAddressResover("test"); Assert.assertThat(aroc.getServers(), is(Arrays.asList("8.8.8.8", "8.8.4.4"))); Assert.assertThat(aroc.getSearchDomains(), is(Arrays.asList("test.svc.local.cluster", "svc.local.cluster", "local.cluster"))); AddressResolverOptions aroc1 = AddressResolverConfig.getAddressResover("test1"); Assert.assertThat(aroc1.getSearchDomains(), is(Arrays.asList("default.svc.local.cluster", "svc.local.cluster", "local.cluster"))); } @Test public void testGetResoverDefault() { ArchaiusUtils.resetConfig(); ArchaiusUtils.setProperty("addressResolver.servers", "8.8.8.8,8.8.4.4"); ArchaiusUtils.setProperty("addressResolver.maxQueries", 3); ArchaiusUtils.setProperty("addressResolver.rdFlag", false); AddressResolverOptions aroc = AddressResolverConfig.getAddressResover("test"); Assert.assertThat(aroc.getServers(), is(Arrays.asList("8.8.8.8", "8.8.4.4"))); Assert.assertEquals(3, aroc.getMaxQueries()); Assert.assertEquals(Integer.MAX_VALUE, aroc.getCacheMaxTimeToLive()); Assert.assertTrue(aroc.isOptResourceEnabled()); Assert.assertNull(aroc.getSearchDomains()); }
ClientPoolManager { public CLIENT_POOL createClientPool(Context context) { CLIENT_POOL pool = factory.createClientPool(context); addPool(context, pool); return pool; } ClientPoolManager(Vertx vertx, ClientPoolFactory<CLIENT_POOL> factory); CLIENT_POOL createClientPool(Context context); CLIENT_POOL findClientPool(boolean sync); CLIENT_POOL findClientPool(boolean sync, Context targetContext); CLIENT_POOL findThreadBindClientPool(); }
@Test public void createClientPool(@Mocked HttpClientWithContext pool) { new Expectations(VertxImpl.class) { { factory.createClientPool(context); result = pool; } }; Assert.assertSame(pool, poolMgr.createClientPool(context)); Assert.assertSame(pool, context.get(id)); Assert.assertThat(pools, Matchers.contains(pool)); }
ClientPoolManager { public CLIENT_POOL findThreadBindClientPool() { assertPoolsInitialized(); int idx = (int) (Thread.currentThread().getId() % pools.size()); return pools.get(idx); } ClientPoolManager(Vertx vertx, ClientPoolFactory<CLIENT_POOL> factory); CLIENT_POOL createClientPool(Context context); CLIENT_POOL findClientPool(boolean sync); CLIENT_POOL findClientPool(boolean sync, Context targetContext); CLIENT_POOL findThreadBindClientPool(); }
@Test public void findThreadBindClientPool(@Mocked HttpClientWithContext pool1, @Mocked HttpClientWithContext pool2) { pools.add(pool1); pools.add(pool2); new MockUp<Thread>() { @Mock long getId() { return 0; } }; Assert.assertSame(pool1, poolMgr.findThreadBindClientPool()); Assert.assertSame(pool1, poolMgr.findThreadBindClientPool()); new MockUp<Thread>() { @Mock long getId() { return 1; } }; Assert.assertSame(pool2, poolMgr.findThreadBindClientPool()); Assert.assertSame(pool2, poolMgr.findThreadBindClientPool()); }
ClientPoolManager { protected CLIENT_POOL findByContext() { return findByContext(null); } ClientPoolManager(Vertx vertx, ClientPoolFactory<CLIENT_POOL> factory); CLIENT_POOL createClientPool(Context context); CLIENT_POOL findClientPool(boolean sync); CLIENT_POOL findClientPool(boolean sync, Context targetContext); CLIENT_POOL findThreadBindClientPool(); }
@Test public void findByContext_wrongContext_reverse() { HttpClientWithContext pool1 = new HttpClientWithContext(null, null); HttpClientWithContext pool2 = new HttpClientWithContext(null, null); pools.add(pool1); pools.add(pool2); new Expectations() { { Vertx.currentContext(); result = null; } }; AtomicInteger reactiveNextIndex = Deencapsulation.getField(poolMgr, "reactiveNextIndex"); reactiveNextIndex.set(Integer.MAX_VALUE); Assert.assertSame(pool2, poolMgr.findByContext()); Assert.assertSame(pool1, poolMgr.findByContext()); Assert.assertSame(pool2, poolMgr.findByContext()); Assert.assertSame(pool1, poolMgr.findByContext()); } @Test public void findByContext_normalThread() { HttpClientWithContext pool = new HttpClientWithContext(null, null); pools.add(pool); new Expectations() { { Vertx.currentContext(); result = null; } }; Assert.assertSame(pool, poolMgr.findByContext()); } @Test public void findByContext_otherVertx(@Mocked VertxImpl otherVertx, @Mocked Context otherContext) { HttpClientWithContext pool = new HttpClientWithContext(null, null); pools.add(pool); new Expectations() { { Vertx.currentContext(); result = otherContext; otherContext.owner(); result = otherVertx; } }; Assert.assertSame(pool, poolMgr.findByContext()); } @Test public void findByContext_worker(@Mocked Context workerContext) { HttpClientWithContext pool = new HttpClientWithContext(null, null); pools.add(pool); new Expectations() { { Vertx.currentContext(); result = workerContext; workerContext.owner(); result = vertx; workerContext.isEventLoopContext(); result = false; } }; Assert.assertSame(pool, poolMgr.findByContext()); }
HttpClientPoolFactory implements ClientPoolFactory<HttpClientWithContext> { @Override public HttpClientWithContext createClientPool(Context context) { HttpClient httpClient = context.owner().createHttpClient(httpClientOptions); httpClient.connectionHandler(connection -> { LOGGER.debug("http connection connected, local:{}, remote:{}.", connection.localAddress(), connection.remoteAddress()); connection.closeHandler(v -> LOGGER.debug("http connection closed, local:{}, remote:{}.", connection.localAddress(), connection.remoteAddress()) ); connection.exceptionHandler(e -> LOGGER.info("http connection exception, local:{}, remote:{}.", connection.localAddress(), connection.remoteAddress(), e) ); }); return new HttpClientWithContext(httpClient, context); } HttpClientPoolFactory(HttpClientOptions httpClientOptions); @Override HttpClientWithContext createClientPool(Context context); }
@Test public void createClientPool(@Mocked VertxInternal vertx, @Mocked ContextInternal context, @Mocked HttpClient httpClient) { new Expectations(VertxImpl.class) { { context.owner(); result = vertx; vertx.createHttpClient(httpClientOptions); result = httpClient; } }; HttpClientWithContext pool = factory.createClientPool(context); Assert.assertSame(context, pool.context()); Assert.assertSame(httpClient, pool.getHttpClient()); }
TcpClientConnection extends TcpConnection { protected TcpOutputStream createLogin() { return null; } TcpClientConnection(Context context, NetClientWrapper netClientWrapper, String strEndpoint); boolean isLocalSupportLogin(); TcpClientConfig getClientConfig(); void setLocalSupportLogin(boolean localSupportLogin); void send(AbstractTcpClientPackage tcpClientPackage, TcpResponseCallback callback); void checkTimeout(); }
@Test public void createLogin() { Assert.assertNull(tcpClientConnection.createLogin()); }
TcpClientConnection extends TcpConnection { protected boolean onLoginResponse(Buffer bodyBuffer) { return true; } TcpClientConnection(Context context, NetClientWrapper netClientWrapper, String strEndpoint); boolean isLocalSupportLogin(); TcpClientConfig getClientConfig(); void setLocalSupportLogin(boolean localSupportLogin); void send(AbstractTcpClientPackage tcpClientPackage, TcpResponseCallback callback); void checkTimeout(); }
@Test public void onLoginResponse_buffer() { Assert.assertTrue(tcpClientConnection.onLoginResponse(null)); }
CreateServiceRequest { public Microservice getService() { return service; } Microservice getService(); void setService(Microservice service); }
@Test public void testDefaultValues() { Assert.assertNull(oCreateServiceRequest.getService()); } @Test public void testInitializedValues() { initCreateServiceRequest(); Assert.assertEquals(oMockMicroservice, oCreateServiceRequest.getService()); }
CpuMeter { public void calcMeasurements(List<Measurement> measurements, long msNow) { update(); measurements.add(new Measurement(allCpuUsage.getId(), msNow, allCpuUsage.getUsage())); measurements.add(new Measurement(processCpuUsage.getId(), msNow, processCpuUsage.getUsage())); } CpuMeter(Id id); void calcMeasurements(List<Measurement> measurements, long msNow); void update(); OsCpuUsage getAllCpuUsage(); ProcessCpuUsage getProcessCpuUsage(); }
@Test public void testCalcMeasurements(@Mocked Id id, @Mocked Runtime runtime, @Mocked RuntimeMXBean mxBean, @Mocked CharSource charSource) throws IOException { List<Measurement> measurements = new ArrayList<>(); new MockUp<Files>() { @Mock public CharSource asCharSource(File file, Charset encoding) { return charSource; } }; new MockUp<CpuUtils>() { @Mock public int calcHertz() { return 4; } }; new MockUp<ManagementFactory>() { @Mock RuntimeMXBean getRuntimeMXBean() { return mxBean; } }; new MockUp<Runtime>() { @Mock public Runtime getRuntime() { return runtime; } }; new Expectations() { { runtime.availableProcessors(); result = 2; charSource.readFirstLine(); result = "1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1"; } }; CpuMeter cpuMeter = new CpuMeter(id); new Expectations() { { charSource.readFirstLine(); result = "2 2 2 2 2 2 2 2 2 0 0 2 2 2 2 2 2 2 2 2 2"; } }; cpuMeter.calcMeasurements(measurements, 0); Assert.assertEquals(2, measurements.size()); Measurement measurement = measurements.get(0); Assert.assertEquals(0, measurement.timestamp()); Assert.assertEquals(0.875, measurement.value(), 0.0); measurement = measurements.get(1); Assert.assertEquals(0, measurement.timestamp()); Assert.assertEquals(0.5, measurement.value(), 0.0); }
TcpClientConnection extends TcpConnection { public void send(AbstractTcpClientPackage tcpClientPackage, TcpResponseCallback callback) { requestMap.put(tcpClientPackage.getMsgId(), new TcpRequest(tcpClientPackage.getMsRequestTimeout(), callback)); if (writeToBufferQueue(tcpClientPackage)) { return; } context.runOnContext(v -> { if (!writeToBufferQueue(tcpClientPackage)) { packageQueue.add(tcpClientPackage); } if (Status.DISCONNECTED.equals(status)) { connect(); } }); } TcpClientConnection(Context context, NetClientWrapper netClientWrapper, String strEndpoint); boolean isLocalSupportLogin(); TcpClientConfig getClientConfig(); void setLocalSupportLogin(boolean localSupportLogin); void send(AbstractTcpClientPackage tcpClientPackage, TcpResponseCallback callback); void checkTimeout(); }
@Test public void send_inWorkingStatus(@Mocked AbstractTcpClientPackage tcpClientPackage, @Mocked TcpOutputStream tcpOutputStream) { Deencapsulation.setField(tcpClientConnection, "status", Status.WORKING); long msgId = 1; ByteBuf byteBuf = Unpooled.buffer(); new Expectations(tcpClientConnection) { { tcpClientPackage.getMsgId(); result = msgId; tcpClientPackage.createStream(); result = tcpOutputStream; tcpOutputStream.getByteBuf(); result = byteBuf; } }; new MockUp<Context>(context) { @Mock void runOnContext(Handler<Void> action) { } }; tcpClientConnection.send(tcpClientPackage, ar -> { }); Assert.assertSame(byteBuf, writeQueue.poll()); Assert.assertNull(writeQueue.poll()); Assert.assertEquals(Status.WORKING, Deencapsulation.getField(tcpClientConnection, "status")); } @Test public void send_inDisconnectedStatus(@Mocked AbstractTcpClientPackage tcpClientPackage, @Mocked TcpOutputStream tcpOutputStream) { long msgId = 1; new Expectations(tcpClientConnection) { { tcpClientPackage.getMsgId(); result = msgId; } }; new MockUp<Context>(context) { @Mock void runOnContext(Handler<Void> action) { action.handle(null); } }; tcpClientConnection.send(tcpClientPackage, ar -> { }); Assert.assertSame(tcpClientPackage, packageQueue.poll()); Assert.assertNull(packageQueue.poll()); Assert.assertEquals(Status.CONNECTING, Deencapsulation.getField(tcpClientConnection, "status")); } @Test public void send_disconnectedToTryLogin(@Mocked AbstractTcpClientPackage tcpClientPackage, @Mocked TcpOutputStream tcpOutputStream) { long msgId = 1; new Expectations(tcpClientConnection) { { tcpClientPackage.getMsgId(); result = msgId; } }; new MockUp<Context>(context) { @Mock void runOnContext(Handler<Void> action) { Deencapsulation.setField(tcpClientConnection, "status", Status.TRY_LOGIN); action.handle(null); } }; tcpClientConnection.send(tcpClientPackage, ar -> { }); Assert.assertSame(tcpClientPackage, packageQueue.poll()); Assert.assertNull(packageQueue.poll()); Assert.assertEquals(Status.TRY_LOGIN, Deencapsulation.getField(tcpClientConnection, "status")); } @Test public void send_disconnectedToWorking(@Mocked AbstractTcpClientPackage tcpClientPackage, @Mocked TcpOutputStream tcpOutputStream) { long msgId = 1; new Expectations(tcpClientConnection) { { tcpClientPackage.getMsgId(); result = msgId; tcpClientConnection.write((ByteBuf) any); } }; new MockUp<Context>(context) { @Mock void runOnContext(Handler<Void> action) { Deencapsulation.setField(tcpClientConnection, "status", Status.WORKING); action.handle(null); } }; tcpClientConnection.send(tcpClientPackage, ar -> { }); Assert.assertNull(writeQueue.poll()); Assert.assertNull(packageQueue.poll()); Assert.assertEquals(Status.WORKING, Deencapsulation.getField(tcpClientConnection, "status")); }
TcpClientConnection extends TcpConnection { @VisibleForTesting protected void connect() { this.status = Status.CONNECTING; LOGGER.info("connecting to address {}", socketAddress.toString()); netClientWrapper.connect(endpoint.isSslEnabled(), socketAddress.getPort(), socketAddress.getHostString(), ar -> { if (ar.succeeded()) { onConnectSuccess(ar.result()); return; } onConnectFailed(ar.cause()); }); } TcpClientConnection(Context context, NetClientWrapper netClientWrapper, String strEndpoint); boolean isLocalSupportLogin(); TcpClientConfig getClientConfig(); void setLocalSupportLogin(boolean localSupportLogin); void send(AbstractTcpClientPackage tcpClientPackage, TcpResponseCallback callback); void checkTimeout(); }
@Test public void connect_success(@Mocked NetSocketImpl netSocket) { FutureFactoryImpl futureFactory = new FutureFactoryImpl(); new MockUp<NetClientWrapper>(netClientWrapper) { @Mock void connect(boolean ssl, int port, String host, Handler<AsyncResult<NetSocket>> connectHandler) { connectHandler.handle(futureFactory.succeededFuture(netSocket)); } }; tcpClientConnection.connect(); Assert.assertSame(netSocket, tcpClientConnection.getNetSocket()); Assert.assertEquals(Status.WORKING, Deencapsulation.getField(tcpClientConnection, "status")); } @Test public void connect_failed() { requestMap.put(10L, new TcpRequest(10, ar -> { })); FutureFactoryImpl futureFactory = new FutureFactoryImpl(); RuntimeException error = new RuntimeExceptionWithoutStackTrace(); new MockUp<NetClientWrapper>(netClientWrapper) { @Mock void connect(boolean ssl, int port, String host, Handler<AsyncResult<NetSocket>> connectHandler) { connectHandler.handle(futureFactory.failedFuture(error)); } }; tcpClientConnection.connect(); Assert.assertEquals(Status.DISCONNECTED, Deencapsulation.getField(tcpClientConnection, "status")); Assert.assertEquals(0, requestMap.size()); }
TcpClientConnection extends TcpConnection { private void onClosed(Void v) { onDisconnected(new IOException("socket closed")); } TcpClientConnection(Context context, NetClientWrapper netClientWrapper, String strEndpoint); boolean isLocalSupportLogin(); TcpClientConfig getClientConfig(); void setLocalSupportLogin(boolean localSupportLogin); void send(AbstractTcpClientPackage tcpClientPackage, TcpResponseCallback callback); void checkTimeout(); }
@Test public void onClosed(@Mocked NetSocketImpl netSocket) { requestMap.put(10L, new TcpRequest(10, ar -> { })); tcpClientConnection.initNetSocket(netSocket); Deencapsulation.invoke(tcpClientConnection, "onClosed", new Class<?>[] {Void.class}, new Object[] {null}); Assert.assertEquals(Status.DISCONNECTED, Deencapsulation.getField(tcpClientConnection, "status")); Assert.assertEquals(0, requestMap.size()); }
TcpClientConnection extends TcpConnection { protected void onReply(long msgId, Buffer headerBuffer, Buffer bodyBuffer) { TcpRequest request = requestMap.remove(msgId); if (request == null) { LOGGER.error("Unknown reply msgId {}, waiting count {}", msgId, requestMap.size()); return; } request.onReply(headerBuffer, bodyBuffer); } TcpClientConnection(Context context, NetClientWrapper netClientWrapper, String strEndpoint); boolean isLocalSupportLogin(); TcpClientConfig getClientConfig(); void setLocalSupportLogin(boolean localSupportLogin); void send(AbstractTcpClientPackage tcpClientPackage, TcpResponseCallback callback); void checkTimeout(); }
@Test public void onReply_notExist() { tcpClientConnection.onReply(1, null, null); } @Test public void on_exist() { long msgId = 1L; AtomicInteger count = new AtomicInteger(); requestMap.put(msgId, new TcpRequest(10, ar -> { count.incrementAndGet(); })); tcpClientConnection.onReply(msgId, null, null); Assert.assertEquals(1, count.get()); }
AbstractTcpClientPoolFactory implements ClientPoolFactory<CLIENT_POOL> { @Override public CLIENT_POOL createClientPool(Context context) { Vertx vertx = context.owner(); NetClientWrapper netClientWrapper = new NetClientWrapper(vertx, normalClientConfig, sslClientConfig); return doCreateClientPool(context, netClientWrapper); } AbstractTcpClientPoolFactory(TcpClientConfig normalClientConfig, TcpClientConfig sslClientConfig); @Override CLIENT_POOL createClientPool(Context context); }
@Test public void createClientPool() { Vertx vertx = Mockito.mock(Vertx.class); Context context = Mockito.mock(Context.class); Mockito.when(context.owner()).thenReturn(vertx); TcpClientConnectionPool pool = factory.createClientPool(context); Assert.assertSame(normalClientConfig, pool.netClientWrapper.getClientConfig(false)); Assert.assertSame(sslClientConfig, pool.netClientWrapper.getClientConfig(true)); }
TcpClientConnectionPool extends AbstractTcpClientConnectionPool<TcpClientConnection> { @Override protected TcpClientConnection create(String endpoint) { return new TcpClientConnection(context, netClientWrapper, endpoint); } TcpClientConnectionPool(Context context, NetClientWrapper netClientWrapper); }
@Test public void create() { Assert.assertThat(pool.create("rest: }
TcpClientConfig extends NetClientOptions { public TcpClientConfig() { msLoginTimeout = DEFAULT_LOGIN_TIMEOUT; } TcpClientConfig(); long getMsLoginTimeout(); void setMsLoginTimeout(long msLoginTimeout); static final int DEFAULT_LOGIN_TIMEOUT; }
@Test public void testTcpClientConfig() { TcpClientConfig config = new TcpClientConfig(); Assert.assertEquals(config.getMsLoginTimeout(), 30000); Assert.assertEquals(config.isSsl(), false); config.setMsLoginTimeout(500); Assert.assertEquals(config.getMsLoginTimeout(), 500); }
NetClientWrapper { public TcpClientConfig getClientConfig(boolean ssl) { if (ssl) { return sslClientConfig; } return normalClientConfig; } NetClientWrapper(Vertx vertx, TcpClientConfig normalClientConfig, TcpClientConfig sslClientConfig); TcpClientConfig getClientConfig(boolean ssl); void connect(boolean ssl, int port, String host, Handler<AsyncResult<NetSocket>> connectHandler); }
@Test public void getClientConfig() { Assert.assertSame(normalClientConfig, netClientWrapper.getClientConfig(false)); Assert.assertSame(sslClientConfig, netClientWrapper.getClientConfig(true)); }
NetClientWrapper { public void connect(boolean ssl, int port, String host, Handler<AsyncResult<NetSocket>> connectHandler) { if (ssl) { sslNetClient.connect(port, host, connectHandler); return; } normalNetClient.connect(port, host, connectHandler); } NetClientWrapper(Vertx vertx, TcpClientConfig normalClientConfig, TcpClientConfig sslClientConfig); TcpClientConfig getClientConfig(boolean ssl); void connect(boolean ssl, int port, String host, Handler<AsyncResult<NetSocket>> connectHandler); }
@Test public void connect(@Mocked NetSocket normalSocket, @Mocked NetSocket sslSocket) { int port = 8000; String host = "localhost"; FutureFactoryImpl futureFactory = new FutureFactoryImpl(); new MockUp<NetClient>(normalNetClient) { @Mock NetClient connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler) { connectHandler.handle(futureFactory.succeededFuture(normalSocket)); return null; } }; new MockUp<NetClient>(sslNetClient) { @Mock NetClient connect(int port, String host, Handler<AsyncResult<NetSocket>> connectHandler) { connectHandler.handle(futureFactory.succeededFuture(sslSocket)); 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()); }); Assert.assertThat(socks, Matchers.contains(normalSocket, sslSocket)); }
ClientVerticle extends AbstractVerticle { @SuppressWarnings("unchecked") @Override public void start() throws Exception { try { ClientPoolManager<CLIENT_POOL> clientMgr = (ClientPoolManager<CLIENT_POOL>) config().getValue(CLIENT_MGR); clientMgr.createClientPool(context); } catch (Throwable e) { LOGGER.error("", e); throw e; } } @SuppressWarnings("unchecked") @Override void start(); static final String CLIENT_MGR; }
@Test public void start(@Mocked Context context) throws Exception { AtomicInteger count = new AtomicInteger(); ClientPoolManager<HttpClientWithContext> clientMgr = new MockUp<ClientPoolManager<HttpClientWithContext>>() { @Mock HttpClientWithContext createClientPool(Context context) { count.incrementAndGet(); return null; } }.getMockInstance(); clientVerticle.init(null, context); JsonObject config = new SimpleJsonObject(); config.put(ClientVerticle.CLIENT_MGR, clientMgr); new Expectations() { { context.config(); result = config; } }; clientVerticle.start(); Assert.assertEquals(1, count.get()); }
TcpParser implements Handler<Buffer> { public void handle(Buffer buf) { parser.handle(buf); } TcpParser(TcpBufferHandler output); boolean firstNEqual(byte[] a, byte[] b, int n); void handle(Buffer buf); static final byte[] TCP_MAGIC; static final int TCP_MAX_REQUEST_LENGTH; static final int TCP_HEADER_LENGTH; }
@Test public void test() throws UnsupportedEncodingException { TcpBufferHandler output = new TcpBufferHandler() { @Override public void handle(long _msgId, Buffer _headerBuffer, Buffer _bodyBuffer) { msgId = _msgId; headerBuffer = _headerBuffer; bodyBuffer = _bodyBuffer; } }; byte[] header = new byte[] {1, 2, 3}; byte[] body = new byte[] {1, 2, 3, 4}; TcpOutputStream os = new TcpOutputStream(1); os.writeInt(header.length + body.length); os.writeInt(header.length); os.write(header); os.write(body); TcpParser parser = new TcpParser(output); parser.handle(os.getBuffer()); os.close(); Assert.assertEquals(1, msgId); Assert.assertArrayEquals(header, headerBuffer.getBytes()); Assert.assertArrayEquals(body, bodyBuffer.getBytes()); }
TcpServer { public void init(Vertx vertx, String sslKey, AsyncResultCallback<InetSocketAddress> callback) { NetServer netServer; if (endpointObject.isSslEnabled()) { SSLOptionFactory factory = SSLOptionFactory.createSSLOptionFactory(sslKey, null); SSLOption sslOption; if (factory == null) { sslOption = SSLOption.buildFromYaml(sslKey); } else { sslOption = factory.createSSLOption(); } SSLCustom sslCustom = SSLCustom.createSSLCustom(sslOption.getSslCustomClass()); NetServerOptions serverOptions = new NetServerOptions(); VertxTLSBuilder.buildNetServerOptions(sslOption, sslCustom, serverOptions); netServer = vertx.createNetServer(serverOptions); } else { netServer = vertx.createNetServer(); } netServer.connectHandler(netSocket -> { DefaultTcpServerMetrics serverMetrics = (DefaultTcpServerMetrics) ((NetSocketImpl) netSocket).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = getConnectionLimit(); if (connectedCount > connectionLimit) { netSocket.close(); endpointMetric.onRejectByConnectionLimit(); return; } TcpServerConnection connection = createTcpServerConnection(); connection.init(netSocket); }); netServer.exceptionHandler(e -> { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); }); InetSocketAddress socketAddress = endpointObject.getSocketAddress(); netServer.listen(socketAddress.getPort(), socketAddress.getHostString(), ar -> { if (ar.succeeded()) { callback.success(socketAddress); return; } String msg = String.format("listen failed, address=%s", socketAddress.toString()); callback.fail(new Exception(msg, ar.cause())); }); } TcpServer(URIEndpointObject endpointObject); void init(Vertx vertx, String sslKey, AsyncResultCallback<InetSocketAddress> callback); }
@SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testTcpServerNonSSL(@Mocked Vertx vertx, @Mocked AsyncResultCallback<InetSocketAddress> callback, @Mocked NetServer netServer) { new Expectations() { { vertx.createNetServer(); result = netServer; netServer.connectHandler((Handler) any); netServer.listen(anyInt, anyString, (Handler) any); } }; URIEndpointObject endpointObject = new URIEndpointObject("highway: TcpServer server = new TcpServerForTest(endpointObject); server.init(vertx, "", callback); } @SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testTcpServerSSL(@Mocked Vertx vertx, @Mocked AsyncResultCallback<InetSocketAddress> callback, @Mocked NetServer netServer) { new Expectations() { { vertx.createNetServer((NetServerOptions) any); result = netServer; netServer.connectHandler((Handler) any); netServer.listen(anyInt, anyString, (Handler) any); } }; URIEndpointObject endpointObject = new URIEndpointObject("highway: TcpServer server = new TcpServerForTest(endpointObject); server.init(vertx, "", callback); } @SuppressWarnings({"rawtypes", "unchecked"}) @Test public void testConnectionLimit(@Mocked Vertx vertx, @Mocked AsyncResultCallback<InetSocketAddress> callback, @Mocked NetServer netServer, @Mocked NetSocketImpl netSocket) { DefaultServerEndpointMetric endpointMetric = new DefaultServerEndpointMetric(null); DefaultTcpServerMetrics tcpServerMetrics = new DefaultTcpServerMetrics(endpointMetric); new MockUp<NetServer>(netServer) { @Mock NetServer connectHandler(Handler<NetSocket> handler) { connectHandler = handler; return netServer; } }; new MockUp<NetSocketImpl>(netSocket) { @Mock void close() { netSocketClosed = true; } }; new Expectations() { { vertx.createNetServer((NetServerOptions) any); result = netServer; netServer.listen(anyInt, anyString, (Handler) any); netSocket.metrics(); result = tcpServerMetrics; } }; URIEndpointObject endpointObject = new URIEndpointObject("highway: TcpServer server = new TcpServerForTest(endpointObject) { @Override protected int getConnectionLimit() { return 2; } }; server.init(vertx, "", callback); endpointMetric.onConnect(); endpointMetric.onConnect(); connectHandler.handle(netSocket); endpointMetric.onConnect(); connectHandler.handle(netSocket); Assert.assertTrue(netSocketClosed); Assert.assertEquals(1, endpointMetric.getRejectByConnectionLimitCount()); }
TcpServerConnection extends TcpConnection { public void init(NetSocket netSocket) { this.initNetSocket((NetSocketImpl) netSocket); String remoteAddress = netSocket.remoteAddress().toString(); LOGGER.info("connect from {}, in thread {}", remoteAddress, Thread.currentThread().getName()); netSocket.exceptionHandler(e -> { LOGGER.error("disconected from {}, in thread {}, cause {}", remoteAddress, Thread.currentThread().getName(), e.getMessage()); }); netSocket.closeHandler(Void -> { LOGGER.error("disconected from {}, in thread {}", remoteAddress, Thread.currentThread().getName()); }); netSocket.handler(splitter); } void init(NetSocket netSocket); }
@Test public void test(@Mocked NetSocketImpl netSocket) { TcpServerConnection connection = new TcpServerConnection(); connection.setProtocol("p"); connection.setZipName("z"); connection.init(netSocket); Assert.assertEquals(netSocket, connection.getNetSocket()); }
CreateServiceResponse { public String getServiceId() { return serviceId; } String getServiceId(); void setServiceId(String serviceId); }
@Test public void testDefaultValues() { Assert.assertNull(oCreateServiceResponse.getServiceId()); } @Test public void testInitializedValues() { initFields(); Assert.assertEquals("testServiceId", oCreateServiceResponse.getServiceId()); }
VertxTLSBuilder { public static NetServerOptions buildNetServerOptions(SSLOption sslOption, SSLCustom sslCustom, NetServerOptions netServerOptions) { buildTCPSSLOptions(sslOption, sslCustom, netServerOptions); if (sslOption.isAuthPeer()) { netServerOptions.setClientAuth(ClientAuth.REQUIRED); } else { netServerOptions.setClientAuth(ClientAuth.REQUEST); } return netServerOptions; } private VertxTLSBuilder(); static NetServerOptions buildNetServerOptions(SSLOption sslOption, SSLCustom sslCustom, NetServerOptions netServerOptions); static void buildHttpClientOptions(String sslKey, HttpClientOptions httpClientOptions); static HttpClientOptions buildHttpClientOptions(SSLOption sslOption, SSLCustom sslCustom, HttpClientOptions httpClientOptions); static ClientOptionsBase buildClientOptionsBase(SSLOption sslOption, SSLCustom sslCustom, ClientOptionsBase clientOptionsBase); }
@Test public void testbuildHttpServerOptions() { SSLOption option = SSLOption.buildFromYaml("rest.provider"); SSLCustom custom = SSLCustom.createSSLCustom(option.getSslCustomClass()); HttpServerOptions serverOptions = new HttpServerOptions(); VertxTLSBuilder.buildNetServerOptions(option, custom, serverOptions); Assert.assertEquals(serverOptions.getEnabledSecureTransportProtocols().toArray().length, 1); Assert.assertEquals(serverOptions.getClientAuth(), ClientAuth.REQUEST); } @Test public void testbuildHttpServerOptionsRequest() { SSLOption option = SSLOption.buildFromYaml("rest.provider"); SSLCustom custom = SSLCustom.createSSLCustom(option.getSslCustomClass()); HttpServerOptions serverOptions = new HttpServerOptions(); new MockUp<SSLOption>() { @Mock public boolean isAuthPeer() { return false; } }; VertxTLSBuilder.buildNetServerOptions(option, custom, serverOptions); Assert.assertEquals(serverOptions.getEnabledSecureTransportProtocols().toArray().length, 1); Assert.assertEquals(serverOptions.getClientAuth(), ClientAuth.REQUEST); }
VertxTLSBuilder { public static void buildHttpClientOptions(String sslKey, HttpClientOptions httpClientOptions) { SSLOptionFactory factory = SSLOptionFactory.createSSLOptionFactory(sslKey, null); SSLOption sslOption; if (factory == null) { sslOption = SSLOption.buildFromYaml(sslKey); } else { sslOption = factory.createSSLOption(); } SSLCustom sslCustom = SSLCustom.createSSLCustom(sslOption.getSslCustomClass()); buildHttpClientOptions(sslOption, sslCustom, httpClientOptions); } private VertxTLSBuilder(); static NetServerOptions buildNetServerOptions(SSLOption sslOption, SSLCustom sslCustom, NetServerOptions netServerOptions); static void buildHttpClientOptions(String sslKey, HttpClientOptions httpClientOptions); static HttpClientOptions buildHttpClientOptions(SSLOption sslOption, SSLCustom sslCustom, HttpClientOptions httpClientOptions); static ClientOptionsBase buildClientOptionsBase(SSLOption sslOption, SSLCustom sslCustom, ClientOptionsBase clientOptionsBase); }
@Test public void testbuildHttpClientOptions_sslKey_noFactory() { HttpClientOptions clientOptions = new HttpClientOptions(); VertxTLSBuilder.buildHttpClientOptions("notExist", clientOptions); Assert.assertTrue(clientOptions.isSsl()); } @Test public void testbuildHttpClientOptions_ssl_withFactory() { ArchaiusUtils.setProperty("ssl.exist.sslOptionFactory", SSLOptionFactoryForTest.class.getName()); HttpClientOptions clientOptions = new HttpClientOptions(); VertxTLSBuilder.buildHttpClientOptions("exist", clientOptions); Assert.assertTrue(clientOptions.isSsl()); Assert.assertTrue(clientOptions.isVerifyHost()); } @Test public void testbuildHttpClientOptions() { SSLOption option = SSLOption.buildFromYaml("rest.consumer"); SSLCustom custom = SSLCustom.createSSLCustom(option.getSslCustomClass()); HttpClientOptions serverOptions = new HttpClientOptions(); VertxTLSBuilder.buildHttpClientOptions(option, custom, serverOptions); Assert.assertEquals(serverOptions.getEnabledSecureTransportProtocols().toArray().length, 1); Assert.assertEquals(serverOptions.isTrustAll(), true); }
VertxTLSBuilder { public static ClientOptionsBase buildClientOptionsBase(SSLOption sslOption, SSLCustom sslCustom, ClientOptionsBase clientOptionsBase) { buildTCPSSLOptions(sslOption, sslCustom, clientOptionsBase); if (sslOption.isAuthPeer()) { clientOptionsBase.setTrustAll(false); } else { clientOptionsBase.setTrustAll(true); } return clientOptionsBase; } private VertxTLSBuilder(); static NetServerOptions buildNetServerOptions(SSLOption sslOption, SSLCustom sslCustom, NetServerOptions netServerOptions); static void buildHttpClientOptions(String sslKey, HttpClientOptions httpClientOptions); static HttpClientOptions buildHttpClientOptions(SSLOption sslOption, SSLCustom sslCustom, HttpClientOptions httpClientOptions); static ClientOptionsBase buildClientOptionsBase(SSLOption sslOption, SSLCustom sslCustom, ClientOptionsBase clientOptionsBase); }
@Test public void testbuildClientOptionsBase() { SSLOption option = SSLOption.buildFromYaml("rest.consumer"); SSLCustom custom = SSLCustom.createSSLCustom(option.getSslCustomClass()); HttpClientOptions serverOptions = new HttpClientOptions(); VertxTLSBuilder.buildClientOptionsBase(option, custom, serverOptions); Assert.assertEquals(serverOptions.getEnabledSecureTransportProtocols().toArray().length, 1); Assert.assertEquals(serverOptions.isTrustAll(), true); } @Test public void testbuildClientOptionsBaseFileNull() { SSLOption option = SSLOption.buildFromYaml("rest.consumer"); option.setKeyStore(null); option.setTrustStore(null); option.setCrl(null); SSLCustom custom = SSLCustom.createSSLCustom(option.getSslCustomClass()); HttpClientOptions serverOptions = new HttpClientOptions(); VertxTLSBuilder.buildClientOptionsBase(option, custom, serverOptions); Assert.assertEquals(serverOptions.getEnabledSecureTransportProtocols().toArray().length, 1); Assert.assertEquals(serverOptions.isTrustAll(), true); } @Test public void testbuildClientOptionsBaseAuthPeerFalse() { SSLOption option = SSLOption.buildFromYaml("rest.consumer"); SSLCustom custom = SSLCustom.createSSLCustom(option.getSslCustomClass()); HttpClientOptions serverOptions = new HttpClientOptions(); new MockUp<SSLOption>() { @Mock public boolean isAuthPeer() { return false; } }; VertxTLSBuilder.buildClientOptionsBase(option, custom, serverOptions); Assert.assertEquals(serverOptions.getEnabledSecureTransportProtocols().toArray().length, 1); Assert.assertEquals(serverOptions.isTrustAll(), true); } @Test public void testbuildClientOptionsBaseSTORE_JKS() { SSLOption option = SSLOption.buildFromYaml("rest.consumer"); SSLCustom custom = SSLCustom.createSSLCustom(option.getSslCustomClass()); HttpClientOptions serverOptions = new HttpClientOptions(); new MockUp<SSLOption>() { @Mock public String getKeyStoreType() { return "JKS"; } }; VertxTLSBuilder.buildClientOptionsBase(option, custom, serverOptions); Assert.assertEquals(serverOptions.getEnabledSecureTransportProtocols().toArray().length, 1); Assert.assertEquals(serverOptions.isTrustAll(), true); } @Test public void testbuildClientOptionsBaseSTORE_PKCS12() { SSLOption option = SSLOption.buildFromYaml("rest.consumer"); SSLCustom custom = SSLCustom.createSSLCustom(option.getSslCustomClass()); HttpClientOptions serverOptions = new HttpClientOptions(); new MockUp<SSLOption>() { @Mock public String getTrustStoreType() { return "PKCS12"; } }; VertxTLSBuilder.buildClientOptionsBase(option, custom, serverOptions); Assert.assertEquals(serverOptions.getEnabledSecureTransportProtocols().toArray().length, 1); Assert.assertEquals(serverOptions.isTrustAll(), true); }
SimpleJsonObject extends JsonObject { @Override public JsonObject put(String key, Object value) { getMap().put(key, value); return this; } @Override JsonObject put(String key, Object value); @Override JsonObject copy(); }
@Test public void testPutObject() { Object value = new Object(); SimpleJsonObject json = new SimpleJsonObject(); json.put("k", value); Assert.assertSame(value, json.getValue("k")); }
SimpleJsonObject extends JsonObject { @Override public JsonObject copy() { return this; } @Override JsonObject put(String key, Object value); @Override JsonObject copy(); }
@Test public void testCopy() { SimpleJsonObject json = new SimpleJsonObject(); Assert.assertSame(json, json.copy()); }
MarkerFilter extends AbstractMatcherFilter<ILoggingEvent> { public MarkerFilter() { setOnMatch(FilterReply.ACCEPT); setOnMismatch(FilterReply.DENY); } MarkerFilter(); @Override FilterReply decide(ILoggingEvent event); void setMarker(String marker); @Override void start(); }
@Test public void testMarkerFilter() { MarkerFilter filter = new MarkerFilter(); filter.setMarker("hello"); filter.start(); Assert.assertEquals(filter.getOnMatch(), FilterReply.ACCEPT); Assert.assertEquals(filter.getOnMismatch(), FilterReply.DENY); ILoggingEvent event = Mockito.mock(ILoggingEvent.class); Marker marker = Mockito.mock(Marker.class); Mockito.when(event.getMarker()).thenReturn(marker); Mockito.when(marker.getName()).thenReturn("hello"); Assert.assertEquals(FilterReply.ACCEPT, filter.decide(event)); Mockito.when(event.getMarker()).thenReturn(null); Assert.assertEquals(FilterReply.DENY, filter.decide(event)); }