src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
HttpStatus implements StatusType { public static boolean isSuccess(int code) { return Status.Family.SUCCESSFUL.equals(Status.Family.familyOf(code)); } HttpStatus(final int statusCode, final String reasonPhrase); static boolean isSuccess(int code); static boolean isSuccess(StatusType status); @Override int getStatusCode(); @Override Family getFamily(); @Override String getReasonPhrase(); } | @Test public void testIsSuccessCode() { Assert.assertTrue(HttpStatus.isSuccess(200)); Assert.assertFalse(HttpStatus.isSuccess(300)); }
@Test public void testIsSuccessType() { Assert.assertTrue(HttpStatus.isSuccess(Status.OK)); Assert.assertFalse(HttpStatus.isSuccess(Status.BAD_REQUEST)); } |
HttpStatus implements StatusType { @Override public int getStatusCode() { return statusCode; } HttpStatus(final int statusCode, final String reasonPhrase); static boolean isSuccess(int code); static boolean isSuccess(StatusType status); @Override int getStatusCode(); @Override Family getFamily(); @Override String getReasonPhrase(); } | @Test public void testGetStatusCode() { HttpStatus status = new HttpStatus(200, "ok"); Assert.assertEquals(200, status.getStatusCode()); } |
HttpStatus implements StatusType { @Override public Family getFamily() { return Family.familyOf(statusCode); } HttpStatus(final int statusCode, final String reasonPhrase); static boolean isSuccess(int code); static boolean isSuccess(StatusType status); @Override int getStatusCode(); @Override Family getFamily(); @Override String getReasonPhrase(); } | @Test public void testGetFamily() { HttpStatus status = new HttpStatus(200, "ok"); Assert.assertEquals(Family.familyOf(200), status.getFamily()); } |
HttpStatus implements StatusType { @Override public String getReasonPhrase() { return reason; } HttpStatus(final int statusCode, final String reasonPhrase); static boolean isSuccess(int code); static boolean isSuccess(StatusType status); @Override int getStatusCode(); @Override Family getFamily(); @Override String getReasonPhrase(); } | @Test public void testGetReasonPhrase() { HttpStatus status = new HttpStatus(200, "ok"); Assert.assertEquals("ok", status.getReasonPhrase()); } |
HttpUtils { public static String parseParamFromHeaderValue(String headerValue, String paramName) { if (StringUtils.isEmpty(headerValue)) { return null; } for (String value : headerValue.split(";")) { int idx = value.indexOf('='); if (idx == -1) { continue; } if (paramName.equalsIgnoreCase(value.substring(0, idx))) { return value.substring(idx + 1); } } return null; } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); } | @Test public void parseParamFromHeaderValue_normal() { Assert.assertEquals("v", HttpUtils.parseParamFromHeaderValue("xx;k=v", "k")); }
@Test public void parseParamFromHeaderValue_normal_ignoreCase() { Assert.assertEquals("v", HttpUtils.parseParamFromHeaderValue("xx;K=v", "k")); }
@Test public void parseParamFromHeaderValue_null() { Assert.assertNull(HttpUtils.parseParamFromHeaderValue(null, "k")); }
@Test public void parseParamFromHeaderValue_noKv() { Assert.assertNull(HttpUtils.parseParamFromHeaderValue("xx", "k")); }
@Test public void parseParamFromHeaderValue_noV() { Assert.assertEquals("", HttpUtils.parseParamFromHeaderValue("xx;k=", "k")); }
@Test public void parseParamFromHeaderValue_keyNotFound() { Assert.assertNull(HttpUtils.parseParamFromHeaderValue("xx;k=", "kk")); } |
GetAllServicesResponse { public List<Microservice> getServices() { return services; } List<Microservice> getServices(); void setServices(List<Microservice> services); } | @Test public void testDefaultValues() { Assert.assertNull(oGetAllServicesResponse.getServices()); }
@Test public void testInitializedValues() { initFields(); List<Microservice> list = oGetAllServicesResponse.getServices(); Assert.assertEquals(oMockMicroservice, list.get(0)); } |
HttpUtils { public static String uriEncodePath(String path) { try { URI uri = new URI(null, null, path, null); return uri.toASCIIString(); } catch (URISyntaxException e) { throw new IllegalArgumentException(String.format("uriEncode failed, path=\"%s\".", path), e); } } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); } | @Test public void uriEncode_null() { Assert.assertEquals("", HttpUtils.uriEncodePath(null)); }
@Test public void uriEncode_chineseAndSpace() { String encoded = HttpUtils.uriEncodePath("测 试"); Assert.assertEquals("%E6%B5%8B%20%E8%AF%95", encoded); Assert.assertEquals("测 试", HttpUtils.uriDecodePath(encoded)); }
@Test public void uriEncode_failed() { expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(Matchers.is("uriEncode failed, path=\":\".")); expectedException.expectCause(Matchers.instanceOf(URISyntaxException.class)); HttpUtils.uriEncodePath(":"); }
@Test public void uriEncode_encodeEntirePath() { String encoded = HttpUtils.uriEncodePath("a%%'+b/def"); Assert.assertEquals("a%25%25'+b/def", encoded); } |
HttpUtils { public static String uriDecodePath(String path) { if (path == null) { return null; } try { return new URI(path).getPath(); } catch (URISyntaxException e) { throw new IllegalArgumentException(String.format("uriDecode failed, path=\"%s\".", path), e); } } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); } | @Test public void uriDecode_null() { Assert.assertNull(HttpUtils.uriDecodePath(null)); }
@Test public void uriDecode_failed() { expectedException.expect(IllegalArgumentException.class); expectedException .expectMessage(Matchers.is("uriDecode failed, path=\":\".")); expectedException.expectCause(Matchers.instanceOf(URISyntaxException.class)); HttpUtils.uriDecodePath(":"); } |
HttpUtils { public static String encodePathParam(String pathParam) { return UrlEscapers.urlPathSegmentEscaper().escape(pathParam); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); } | @Test public void pathParamEncode() { Assert.assertEquals("a+b", HttpUtils.encodePathParam("a+b")); Assert.assertEquals("a%25b", HttpUtils.encodePathParam("a%b")); Assert.assertEquals("a%25%25b", HttpUtils.encodePathParam("a%%b")); Assert.assertEquals("%3C%20%3E'%22%EF%BC%88)&%2F%20%20", HttpUtils.encodePathParam("< >'\"（)&/ ")); Assert.assertEquals("%E6%B5%8B%20%E8%AF%95", HttpUtils.encodePathParam("测 试")); }
@Test public void pathParamEncode_SafeChar() { Assert.assertEquals("-._~!$'()*,;&=@:+", HttpUtils.encodePathParam("-._~!$'()*,;&=@:+")); } |
HttpUtils { public static String parseFileNameFromHeaderValue(String headerValue) { String fileName = parseParamFromHeaderValue(headerValue, "filename"); fileName = StringUtils.isEmpty(fileName) ? "default" : fileName; fileName = uriDecodePath(fileName); return new File(fileName).getName(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); } | @Test public void parseFileNameFromHeaderValue() { String fileName = "测 试.txt"; String encoded = HttpUtils.uriEncodePath(fileName); Assert.assertEquals(fileName, HttpUtils.parseFileNameFromHeaderValue("xx;filename=" + encoded)); }
@Test public void parseFileNameFromHeaderValue_defaultName() { Assert.assertEquals("default", HttpUtils.parseFileNameFromHeaderValue("xx")); }
@Test public void parseFileNameFromHeaderValue_ignorePath() { Assert.assertEquals("a.txt", HttpUtils.parseFileNameFromHeaderValue("xx;filename=../../a.txt")); } |
HttpUtils { public static String getCharsetFromContentType(String contentType) { if (contentType == null) { return null; } int start = contentType.indexOf("charset="); if (start < 0) { return null; } String encoding = contentType.substring(start + 8); int end = encoding.indexOf(';'); if (end >= 0) { encoding = encoding.substring(0, end); } encoding = encoding.trim(); if ((encoding.length() > 2) && (encoding.startsWith("\"")) && (encoding.endsWith("\""))) { encoding = encoding.substring(1, encoding.length() - 1); } return encoding.trim(); } private HttpUtils(); static String parseParamFromHeaderValue(String headerValue, String paramName); static String uriEncodePath(String path); static String encodePathParam(String pathParam); static String uriDecodePath(String path); static String parseFileNameFromHeaderValue(String headerValue); static String getCharsetFromContentType(String contentType); } | @Test public void getCharsetFromContentType_noContentType() { String character = HttpUtils.getCharsetFromContentType(null); Assert.assertNull(character); }
@Test public void getCharsetFromContentType_noCharset() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON); Assert.assertNull(character); }
@Test public void getCharsetFromContentType_noSemicolonEnd() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=utf-8"); Assert.assertEquals("utf-8", character); }
@Test public void getCharsetFromContentType_semicolonEnd() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=utf-8;"); Assert.assertEquals("utf-8", character); }
@Test public void getCharsetFromContentType_needTrim() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset= utf-8 ;"); Assert.assertEquals("utf-8", character); }
@Test public void getCharsetFromContentType_quotationMarks() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=\"utf-8\";"); Assert.assertEquals("utf-8", character); }
@Test public void getCharsetFromContentType_quotationMarks_needTrim() { String character = HttpUtils.getCharsetFromContentType(MediaType.APPLICATION_JSON + ";charset=\" utf-8 \";"); Assert.assertEquals("utf-8", character); } |
RegisterInstanceResponse { public String getInstanceId() { return instanceId; } String getInstanceId(); void setInstanceId(String instanceId); } | @Test public void testDefaultValues() { Assert.assertNull(oRegisterInstanceResponse.getInstanceId()); }
@Test public void testInitializedValues() { initFields(); Assert.assertEquals("testInstanceID", oRegisterInstanceResponse.getInstanceId()); } |
HttpStatusUtils { public static StatusType getOrCreateByStatusCode(int code) { return MGR.getOrCreateByStatusCode(code); } private HttpStatusUtils(); static StatusType getOrCreateByStatusCode(int code); } | @Test public void testStandard() { st = HttpStatusUtils.getOrCreateByStatusCode(200); Assert.assertEquals(200, st.getStatusCode()); }
@Test public void testNotStandard() { st = mgr.getOrCreateByStatusCode(250); Assert.assertEquals(250, st.getStatusCode()); } |
FilePart extends AbstractPart implements FilePartForSend { @Override public InputStream getInputStream() throws IOException { return new FileInputStream(file); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); } | @Test public void getInputStream() throws IOException { try (InputStream is = part.getInputStream()) { Assert.assertEquals(content, IOUtils.toString(is, StandardCharsets.UTF_8)); } } |
FilePart extends AbstractPart implements FilePartForSend { @Override public long getSize() { return file.length(); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); } | @Test public void getSize() { Assert.assertEquals(content.length(), part.getSize()); } |
FilePart extends AbstractPart implements FilePartForSend { @Override public void write(String fileName) throws IOException { FileUtils.copyFile(file, new File(fileName)); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); } | @Test public void write() throws IOException { File destFile = new File("testFilePartCopy.txt"); part.write(destFile.getPath()); Assert.assertEquals(content, FileUtils.readFileToString(destFile, StandardCharsets.UTF_8)); FilePart destPart = new FilePart(null, destFile); destPart.delete(); Assert.assertFalse(destFile.exists()); } |
FilePart extends AbstractPart implements FilePartForSend { @Override public String getAbsolutePath() { return file.getAbsolutePath(); } FilePart(String name, String file); FilePart(String name, File file); @Override InputStream getInputStream(); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override boolean isDeleteAfterFinished(); FilePart setDeleteAfterFinished(boolean deleteAfterFinished); @Override String getAbsolutePath(); } | @Test public void getAbsolutePath() { Assert.assertEquals(file.getAbsolutePath(), part.getAbsolutePath()); } |
AbstractPart implements Part { @Override public InputStream getInputStream() throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void getInputStream() throws IOException { initExpectedException(); part.getInputStream(); } |
AbstractPart implements Part { @Override public String getContentType() { return contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void getContentType() throws IOException { Assert.assertEquals(MediaType.APPLICATION_OCTET_STREAM, part.getContentType()); String contentType = "abc"; part.contentType(contentType); Assert.assertEquals(contentType, part.getContentType()); } |
AbstractPart implements Part { @Override public String getName() { return name; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void getName() throws IOException { Assert.assertNull(part.getName()); String name = "abc"; part.name = name; Assert.assertEquals(name, part.getName()); } |
AbstractPart implements Part { @Override public String getSubmittedFileName() { return submittedFileName; } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void getSubmittedFileName() throws IOException { Assert.assertNull(part.getSubmittedFileName()); String submittedFileName = "abc"; part.setSubmittedFileName(submittedFileName); Assert.assertEquals(submittedFileName, part.getSubmittedFileName()); } |
AbstractPart implements Part { @Override public long getSize() { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void getSize() { initExpectedException(); part.getSize(); } |
AbstractPart implements Part { @Override public void write(String fileName) throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void write() throws IOException { initExpectedException(); part.write("file"); } |
AbstractPart implements Part { @Override public void delete() throws IOException { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void delete() throws IOException { initExpectedException(); part.delete(); } |
AbstractPart implements Part { @Override public String getHeader(String name) { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void getHeader() { initExpectedException(); part.getHeader("header"); } |
AbstractPart implements Part { @Override public Collection<String> getHeaders(String name) { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void getHeaders() { initExpectedException(); part.getHeaders("header"); } |
AbstractPart implements Part { @Override public Collection<String> getHeaderNames() { throw new Error("not supported method"); } @Override InputStream getInputStream(); @Override String getContentType(); @SuppressWarnings("unchecked") T contentType(String contentType); @Override String getName(); @Override String getSubmittedFileName(); AbstractPart setSubmittedFileName(String submittedFileName); @Override long getSize(); @Override void write(String fileName); @Override void delete(); @Override String getHeader(String name); @Override Collection<String> getHeaders(String name); @Override Collection<String> getHeaderNames(); } | @Test public void getHeaderNames() { initExpectedException(); part.getHeaderNames(); } |
ResourcePart extends AbstractPart { @Override public InputStream getInputStream() throws IOException { return resource.getInputStream(); } ResourcePart(String name, Resource resource); @Override InputStream getInputStream(); } | @Test public void getInputStream() throws IOException { try (InputStream is = part.getInputStream()) { byte[] content = IOUtils.toByteArray(is); Assert.assertArrayEquals(bytes, content); } } |
NetUtils { private NetUtils() { } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); } | @Test public void testNetUtils() { Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("127.0.0.1:8080").getHostOrIp()); Assert.assertEquals(8080, NetUtils.parseIpPort("127.0.0.1:8080").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("127.0.0.1").getHostOrIp()); Assert.assertEquals(-1, NetUtils.parseIpPort("127.0.0.1").getPort()); Assert.assertEquals(null, NetUtils.parseIpPort((String) null)); Assert.assertEquals(null, NetUtils.parseIpPortFromURI(null)); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPortFromURI("rest: Assert.assertEquals(8080, NetUtils.parseIpPortFromURI("http: Assert.assertEquals(80, NetUtils.parseIpPortFromURI("http: Assert.assertEquals(8080, NetUtils.parseIpPortFromURI("https: Assert.assertEquals(443, NetUtils.parseIpPortFromURI("https: Assert.assertEquals(30000, NetUtils.parseIpPort("http", "127.0.0.1:30000").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("http", "127.0.0.1:30000").getHostOrIp()); Assert.assertEquals(30000, NetUtils.parseIpPort("https", "127.0.0.1:30000").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("https", "127.0.0.1:30000").getHostOrIp()); Assert.assertEquals(80, NetUtils.parseIpPort("http", "127.0.0.1").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("http", "127.0.0.1").getHostOrIp()); Assert.assertEquals(443, NetUtils.parseIpPort("https", "127.0.0.1").getPort()); Assert.assertEquals("127.0.0.1", NetUtils.parseIpPort("https", "127.0.0.1").getHostOrIp()); Assert.assertNull(NetUtils.parseIpPort("http", null)); checkException(v -> NetUtils.parseIpPort("127.0.0.18080")); checkException(v -> NetUtils.parseIpPortFromURI("ss")); } |
GetServiceResponse { public Microservice getService() { return service; } Microservice getService(); void setService(Microservice service); } | @Test public void testDefaultValues() { Assert.assertNull(oGetServiceResponse.getService()); }
@Test public void testInitializedValues() { initFields(); Assert.assertEquals(oMockMicroservice, oGetServiceResponse.getService()); } |
NetUtils { public static String getRealListenAddress(String schema, String address) { if (address == null) { return null; } try { URI originalURI = new URI(schema + ": IpPort ipPort = NetUtils.parseIpPort(originalURI); if (ipPort == null) { LOGGER.error("address {} is not valid.", address); return null; } return originalURI.toString(); } catch (URISyntaxException e) { LOGGER.error("address {} is not valid.", address); return null; } } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); } | @Test public void testGetRealListenAddress() { Assert.assertNull(NetUtils.getRealListenAddress("http", null)); Assert.assertEquals("http: checkException(v -> NetUtils.getRealListenAddress("http:1", "1.1.1.1:8080")); } |
NetUtils { @SuppressWarnings({"unused", "try"}) public static boolean canTcpListen(InetAddress address, int port) { try (ServerSocket ss = new ServerSocket(port, 0, address)) { return true; } catch (IOException e) { return false; } } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); } | @Test public void testCanTcpListenNo() throws IOException { InetAddress address = InetAddress.getByName("127.0.0.1"); try (ServerSocket ss = new ServerSocket(0, 0, address)) { Assert.assertFalse(NetUtils.canTcpListen(address, ss.getLocalPort())); } }
@Test public void testCanTcpListenYes() throws IOException { InetAddress address = InetAddress.getByName("127.0.0.1"); ServerSocket ss = new ServerSocket(0, 0, address); int port = ss.getLocalPort(); ss.close(); Assert.assertTrue(NetUtils.canTcpListen(address, port)); } |
NetUtils { public static String humanReadableBytes(long bytes) { int unit = 1024; if (bytes < unit) { return String.valueOf(bytes); } int exp = (int) (Math.log(bytes) / Math.log(unit)); char pre = "KMGTPE".charAt(exp - 1); return String.format("%.3f%c", bytes / Math.pow(unit, exp), pre); } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); } | @Test public void humanReadableBytes() { Assert.assertEquals("0", NetUtils.humanReadableBytes(0L)); Assert.assertEquals("1", NetUtils.humanReadableBytes(1L)); Assert.assertEquals("1023", NetUtils.humanReadableBytes(1023L)); Assert.assertEquals("1.000K", NetUtils.humanReadableBytes(1024L)); Assert.assertEquals("1.001K", NetUtils.humanReadableBytes(1025L)); Assert.assertEquals("1023.999K", NetUtils.humanReadableBytes(1024L * 1024 - 1)); Assert.assertEquals("1.000M", NetUtils.humanReadableBytes(1024L * 1024)); Assert.assertEquals("1.000M", NetUtils.humanReadableBytes(1024L * 1024 + 1)); Assert.assertEquals("1.001M", NetUtils.humanReadableBytes(1024L * 1024 + 1024)); Assert.assertEquals("1023.999M", NetUtils.humanReadableBytes(1024L * 1024 * 1024 - 1024)); Assert.assertEquals("1024.000M", NetUtils.humanReadableBytes(1024L * 1024 * 1024 - 1)); Assert.assertEquals("1.000G", NetUtils.humanReadableBytes(1024L * 1024 * 1024)); Assert.assertEquals("1.000G", NetUtils.humanReadableBytes(1024L * 1024 * 1024 + 1)); Assert.assertEquals("1.000G", NetUtils.humanReadableBytes(1024L * 1024 * 1024 + 1024)); Assert.assertEquals("1023.999G", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 - 1024 * 1024)); Assert.assertEquals("1024.000G", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 - 1024)); Assert.assertEquals("1.000T", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024)); Assert.assertEquals("1.001T", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 + 1024 * 1024 * 1024)); Assert.assertEquals("1023.999T", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 - 1024L * 1024 * 1024)); Assert.assertEquals("1.000P", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024)); Assert.assertEquals("1.001P", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 + 1024L * 1024 * 1024 * 1024)); Assert.assertEquals("1023.999P", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 * 1024 - 1024L * 1024 * 1024 * 1024)); Assert.assertEquals("1.000E", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 * 1024)); Assert.assertEquals("1.001E", NetUtils.humanReadableBytes(1024L * 1024 * 1024 * 1024 * 1024 * 1024 + 1024L * 1024 * 1024 * 1024 * 1024)); Assert.assertEquals("8.000E", NetUtils.humanReadableBytes(Long.MAX_VALUE)); } |
NetUtils { public static String getHostName() { if (hostName == null) { doGetHostNameAndHostAddress(); } return hostName; } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); } | @Test public void testGetHostName() { Assert.assertNotEquals(null, NetUtils.getHostName()); Deencapsulation.setField(NetUtils.class, "hostName", null); Assert.assertNotEquals(null, NetUtils.getHostName()); } |
NetUtils { public static String getHostAddress() { if (hostAddress == null) { doGetHostNameAndHostAddress(); } return hostAddress; } private NetUtils(); static IpPort parseIpPort(String address); static IpPort parseIpPort(URI uri); static IpPort parseIpPort(URI uri, boolean ignorePortUndefined); static IpPort parseIpPortFromURI(String uriAddress); static IpPort parseIpPort(String scheme, String authority); static String getRealListenAddress(String schema, String address); static String getHostName(); static String getHostAddress(); static InetAddress getInterfaceAddress(String interfaceName); static InetAddress ensureGetInterfaceAddress(String interfaceName); @SuppressWarnings({"unused", "try"}) static boolean canTcpListen(InetAddress address, int port); static String humanReadableBytes(long bytes); } | @Test public void testGetHostAddress() { Assert.assertNotEquals(null, NetUtils.getHostAddress()); Deencapsulation.setField(NetUtils.class, "hostAddress", null); Assert.assertNotEquals(null, NetUtils.getHostAddress()); } |
IpPort { public IpPort() { } IpPort(); IpPort(String hostOrIp, int port); String getHostOrIp(); void setHostOrIp(String hostOrIp); int getPort(); void setPort(int port); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); InetSocketAddress getSocketAddress(); } | @Test public void testIpPort() { IpPort inst1 = new IpPort(); inst1.setHostOrIp("localhost"); inst1.setPort(3333); IpPort inst2 = new IpPort("localhost", 3333); Assert.assertEquals(inst1.getHostOrIp(), inst2.getHostOrIp()); Assert.assertEquals(inst1.getPort(), inst2.getPort()); Assert.assertEquals(inst1.getSocketAddress().getHostName(), inst2.getSocketAddress().getHostName()); Assert.assertEquals(inst1, inst1); Assert.assertEquals(inst1, inst2); Assert.assertEquals(inst1.toString(), "localhost:3333"); Assert.assertNotEquals(inst1, new Object()); } |
FortifyUtils { private FortifyUtils() { } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); } | @Test public void testFortifyUtils() throws IOException { Assert.assertEquals("", FortifyUtils.getErrorMsg(null)); Assert.assertEquals("", FortifyUtils.getErrorStack(null)); } |
FortifyUtils { public static String getErrorMsg(Throwable e) { if (e == null) { return ""; } try { return (String) getMessageMethod.invoke(e); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); } | @Test public void testGetErrorMsg() { Throwable e = new Throwable(); FortifyUtils.getErrorMsg(e); assertNull(FortifyUtils.getErrorMsg(e)); } |
FortifyUtils { public static DocumentBuilderFactory getSecurityXmlDocumentFactory() throws ParserConfigurationException { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setFeature("http: factory.setXIncludeAware(false); factory.setExpandEntityReferences(false); factory.setFeature("http: factory.setFeature("http: factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); factory.setValidating(true); return factory; } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); } | @Test public void testGetSecurityXmlDocumentFactory() { try { FortifyUtils.getSecurityXmlDocumentFactory(); assertNotNull(FortifyUtils.getSecurityXmlDocumentFactory()); } catch (Exception e) { Assert.assertTrue(false); } } |
FortifyUtils { public static String getErrorStack(Throwable e) { if (null == e) { return ""; } try { StringWriter errors = new StringWriter(); printStackTraceMethod.invoke(e, new PrintWriter(errors)); return errors.toString(); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { return ""; } } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); } | @Test public void testGetErrorStack() { Throwable e = new Throwable(); FortifyUtils.getErrorStack(e); Assert.assertNotEquals(true, FortifyUtils.getErrorStack(e)); } |
FortifyUtils { public static String getErrorInfo(Throwable e) { return getErrorInfo(e, true); } private FortifyUtils(); static String getErrorMsg(Throwable e); static String getErrorStack(Throwable e); static String getErrorInfo(Throwable e); static String getErrorInfo(Throwable e, boolean isPrintMsg); static DocumentBuilderFactory getSecurityXmlDocumentFactory(); } | @Test public void testGetErrorInfo() { Throwable e = new Throwable(); FortifyUtils.getErrorInfo(e, true); Assert.assertNotEquals(true, FortifyUtils.getErrorInfo(e, true)); } |
MimeTypesUtils { public static List<String> getSortedAcceptableMimeTypes(String acceptHeader) { if (acceptHeader == null) { return Collections.emptyList(); } String[] items = COMMA_SPLITTER.split(acceptHeader); Arrays.sort(items, ACCEPT_X_COMPARATOR); List<String> list = new ArrayList<>(items.length); for (String item : items) { int space = item.indexOf(';'); if (space != -1) { list.add(item.substring(0, space)); } else { list.add(item); } } return list; } static List<String> getSortedAcceptableMimeTypes(String acceptHeader); } | @Test public void testSortedAcceptableMimeTypes1() { String accept = "text/html"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(1, types.size()); assertEquals("text/html", types.get(0)); }
@Test public void testSortedAcceptableMimeTypes2() { String accept = "text/html, application/json"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(2, types.size()); assertEquals("text/html", types.get(0)); assertEquals("application/json", types.get(1)); }
@Test public void testSortedAcceptableMimeTypes3() { String accept = "text/html,application/json"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(2, types.size()); assertEquals("text/html", types.get(0)); assertEquals("application/json", types.get(1)); }
@Test public void testSortedAcceptableMimeTypes4() { String accept = "text/html; q=0.8,application/json; q=0.9"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(2, types.size()); assertEquals("application/json", types.get(0)); assertEquals("text/html", types.get(1)); }
@Test public void testSortedAcceptableMimeTypes5() { String accept = "text/html;q=0.8,application/json;q=0.9"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(2, types.size()); assertEquals("application/json", types.get(0)); assertEquals("text/html", types.get(1)); }
@Test public void testSortedAcceptableMimeTypes6() { String accept = "text/html; q=0.8,application/json; q=0.9, text/plain"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(3, types.size()); assertEquals("text/plain", types.get(0)); assertEquals("application/json", types.get(1)); assertEquals("text/html", types.get(2)); }
@Test public void testSortedAcceptableMimeTypes7() { String accept = "text/html;q=0.8,application/json;q=0.9,text/plain"; List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(accept); assertEquals(3, types.size()); assertEquals("text/plain", types.get(0)); assertEquals("application/json", types.get(1)); assertEquals("text/html", types.get(2)); }
@Test public void getSortedAcceptableMimeTypesNull() { List<String> types = MimeTypesUtils.getSortedAcceptableMimeTypes(null); Assert.assertSame(Collections.emptyList(), types); } |
GetInstancesResponse { public List<MicroserviceInstance> getInstances() { return instances; } List<MicroserviceInstance> getInstances(); void setInstances(List<MicroserviceInstance> instances); } | @Test public void testDefaultValues() { Assert.assertNull(oGetInstancesResponse.getInstances()); }
@Test public void testInitializedValues() { initFields(); Assert.assertEquals(1, oGetInstancesResponse.getInstances().size()); } |
NetMeter { public void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval) { refreshNet(secondInterval); interfaceUsageMap.values().forEach(interfaceUsage -> { interfaceUsage.calcMeasurements(measurements, msNow); }); } NetMeter(Id id); void calcMeasurements(List<Measurement> measurements, long msNow, long secondInterval); Map<String, InterfaceUsage> getInterfaceUsageMap(); static final String STATISTIC; static final String INTERFACE; static final Tag TAG_RECEIVE; static final Tag TAG_PACKETS_RECEIVE; static final Tag TAG_SEND; static final Tag TAG_PACKETS_SEND; } | @Test public void testCalcMeasurements(@Mocked Id id) { List<String> list = new ArrayList<>(); list.add("useless"); list.add("useless"); list.add("eth0: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"); new MockUp<FileUtils>() { @Mock public List<String> readLines(File file, Charset encoding) { return list; } }; NetMeter netMeter = new NetMeter(id); list.remove(2); list.add("eth0: 3 1 0 0 0 0 0 1 3 1 1 0 0 0 0 0"); List<Measurement> measurements = new ArrayList<>(); netMeter.calcMeasurements(measurements, 0L, 1); Assert.assertEquals(4, measurements.size()); Measurement receive = measurements.get(0); Measurement send = measurements.get(1); Measurement receivePackets = measurements.get(2); Measurement sendPackets = measurements.get(3); Assert.assertEquals(3.0, send.value(), 0.0); Assert.assertEquals(1.0, sendPackets.value(), 0.0); Assert.assertEquals(3.0, receive.value(), 0.0); Assert.assertEquals(1.0, receivePackets.value(), 0.0); } |
SPIServiceUtils { public static <T> T getTargetService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); } | @Test public void testGetTargetServiceNull() { SPIServiceDef0 service = SPIServiceUtils.getTargetService(SPIServiceDef0.class); Assert.assertNull(service); }
@Test public void testGetTargetServiceNotNull() { SPIServiceDef service = SPIServiceUtils.getTargetService(SPIServiceDef.class); Assert.assertTrue(SPIServiceDef.class.isInstance(service)); Assert.assertSame(service, SPIServiceUtils.getTargetService(SPIServiceDef.class)); }
@Test public void testGetTargetService_special_null() { Assert.assertNull(SPIServiceUtils.getTargetService(SPIServiceDef0.class, SPIServiceDef0Impl.class)); }
@Test public void testGetTargetService_special_notNull() { SPIServiceDef service = SPIServiceUtils.getTargetService(SPIServiceDef.class, SPIServiceDefImpl.class); Assert.assertTrue(SPIServiceDefImpl.class.isInstance(service)); } |
SPIServiceUtils { public static <T> T getPriorityHighestService(Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } return services.get(0); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); } | @Test public void getPriorityHighestService_null() { Assert.assertNull(SPIServiceUtils.getPriorityHighestService(SPIServiceDef0.class)); } |
SPIServiceUtils { public static <T> Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType) { List<T> services = getOrLoadSortedService(serviceType); if (services.isEmpty()) { LOGGER.info("Can not find SPI service for {}", serviceType.getName()); return null; } Map<String, T> map = new HashMap<>(); services.forEach(instance -> map.putIfAbsent(keyFunc.apply(instance), instance)); return map.values(); } private SPIServiceUtils(); static List<T> loadSortedService(Class<T> serviceType); @SuppressWarnings("unchecked") static List<T> getOrLoadSortedService(Class<T> serviceType); static T getTargetService(Class<T> serviceType); static List<T> getAllService(Class<T> serviceType); static List<T> getSortedService(Class<T> serviceType); static T getPriorityHighestService(Class<T> serviceType); static Collection<T> getPriorityHighestServices(Function<T, String> keyFunc, Class<T> serviceType); @SuppressWarnings("unchecked") static IMPL getTargetService(Class<T> serviceType, Class<IMPL> implType); } | @Test public void getPriorityHighestServices() { Map<String, PriorityIntf> instances = new LinkedHashMap<>(); instances.putIfAbsent("1", new PriorityImpl("n1", 0)); instances.putIfAbsent("2", new PriorityImpl("n1", -1)); instances.putIfAbsent("3", new PriorityImpl("n1", 1)); instances.putIfAbsent("4", new PriorityImpl("n2", 0)); instances.putIfAbsent("5", new PriorityImpl("n2", -1)); instances.putIfAbsent("6", new PriorityImpl("n2", 1)); ServiceLoader<PriorityIntf> serviceLoader = ServiceLoader.load(PriorityIntf.class); Deencapsulation.setField(serviceLoader, "providers", instances); new Expectations(ServiceLoader.class) { { ServiceLoader.load(PriorityIntf.class); result = serviceLoader; } }; Assert.assertThat(SPIServiceUtils.getPriorityHighestServices(inst -> inst.getName(), PriorityIntf.class), Matchers.containsInAnyOrder(instances.get("2"), instances.get("5"))); Map<Class<?>, List<Object>> cache = Deencapsulation.getField(SPIServiceUtils.class, "cache"); cache.clear(); } |
LambdaMetafactoryUtils { @SuppressWarnings("unchecked") public static <T> T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls) { try { Method intfMethod = findAbstractMethod(functionalIntfCls); MethodHandle methodHandle = LOOKUP.unreflect(instanceMethod); MethodType intfMethodType = MethodType.methodType(intfMethod.getReturnType(), intfMethod.getParameterTypes()); MethodType instanceMethodType = MethodType .methodType(instanceMethod.getReturnType(), instanceMethod.getParameterTypes()); CallSite callSite = LambdaMetafactory.metafactory( LOOKUP, intfMethod.getName(), MethodType.methodType(functionalIntfCls, instance.getClass()), intfMethodType, methodHandle, instanceMethodType); return (T) callSite.getTarget().bindTo(instance).invoke(); } catch (Throwable e) { throw new IllegalStateException("Failed to create lambda from " + instanceMethod, e); } } private LambdaMetafactoryUtils(); @SuppressWarnings("unchecked") static T createLambda(Object instance, Method instanceMethod, Class<?> functionalIntfCls); @SuppressWarnings("unchecked") static T createLambda(Method instanceMethod, Class<?> functionalIntfCls); static T createGetter(Method getMethod); @SuppressWarnings("unchecked") static Getter<Object, Object> createObjectGetter(Method getMethod); static Getter<Object, Object> createObjectGetter(BeanPropertyDefinition propertyDefinition); @SuppressWarnings("unchecked") static Getter<C, F> createGetter(Field field); static T createSetter(Method setMethod); @SuppressWarnings("unchecked") static Setter<Object, Object> createObjectSetter(Method setMethod); static Setter<Object, Object> createObjectSetter(BeanPropertyDefinition propertyDefinition); static Setter<C, F> createSetter(Field field); } | @SuppressWarnings("unchecked") @Test public void createLambda_withInstance() throws Throwable { Supplier<Object> getter = LambdaMetafactoryUtils .createLambda(model, Model.class.getMethod("getF1"), Supplier.class); Consumer<Object> setter = LambdaMetafactoryUtils .createLambda(model, Model.class.getMethod("setF1", int.class), Consumer.class); Function<Object, Object> echo = LambdaMetafactoryUtils .createLambda(model, Model.class.getMethod("echo", List.class), Function.class); setter.accept(1); int f1 = (int) getter.get(); Assert.assertEquals(1, f1); Assert.assertThat((List<Integer>) echo.apply(Arrays.asList(2)), Matchers.contains(2)); } |
GenericsUtils { public static boolean isGenericResponseType(Type type) { if (type instanceof ParameterizedType) { return false; } if (type instanceof Class<?>) { return ((Class<?>) type).getTypeParameters().length > 0; } return true; } static boolean isGenericResponseType(Type type); } | @Test public void testIsGenerics() { Assert.assertTrue(GenericsUtils.isGenericResponseType(List.class)); Assert.assertTrue(GenericsUtils.isGenericResponseType(Map.class)); Assert.assertTrue(GenericsUtils.isGenericResponseType(Person.class)); Assert.assertFalse(GenericsUtils.isGenericResponseType(Man.class)); Assert.assertFalse(GenericsUtils.isGenericResponseType(String.class)); Assert.assertFalse(GenericsUtils.isGenericResponseType(GenericsUtils.class)); Assert.assertFalse(GenericsUtils.isGenericResponseType(new ParameterizedTypeReference<List<Man>>() { }.getType())); } |
ExceptionUtils { private ExceptionUtils() { } private ExceptionUtils(); static String getExceptionMessageWithoutTrace(Throwable e); } | @Test public void testExceptionUtils() { Exception e = new Exception("Hello"); Assert.assertEquals("cause:Exception,message:Hello", ExceptionUtils.getExceptionMessageWithoutTrace(e)); Exception e2 = new Exception("FAIL", new IOException("IO")); Assert.assertEquals("cause:Exception,message:FAIL;cause:IOException,message:IO", ExceptionUtils.getExceptionMessageWithoutTrace(e2)); } |
ResourceUtil { public static List<URI> findResources(String resourceLocation) throws IOException, URISyntaxException { return findResources(resourceLocation, p -> true); } private ResourceUtil(); static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix); static List<URI> findResources(String resourceLocation); static List<URI> findResources(String resourceLocation, Predicate<Path> filter); } | @Test public void loadResources_in_jar() throws IOException, URISyntaxException { List<URI> uris = ResourceUtil.findResources("META-INF", p -> p.toString().endsWith("spring.factories")); Assert.assertEquals(1, uris.size()); Assert.assertTrue(uris.get(0).toString().startsWith("jar:file:")); Assert.assertTrue(uris.get(0).toString().endsWith("!/META-INF/spring.factories")); }
@Test public void loadResources_exact_file_in_disk() throws IOException, URISyntaxException { List<URI> uris = ResourceUtil.findResources("META-INF/spring/config.bean.xml"); Assert.assertEquals(1, uris.size()); URI uri = uris.get(0); Assert.assertTrue("unexpected uri: " + uri, uri.toString().startsWith("file:")); Assert.assertTrue("unexpected uri: " + uri, uri.toString().endsWith("META-INF/spring/config.bean.xml")); } |
ResourceUtil { public static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix) throws IOException, URISyntaxException { return findResources(resourceLocation, path -> path.toString().endsWith(fileNameSuffix)); } private ResourceUtil(); static List<URI> findResourcesBySuffix(String resourceLocation, String fileNameSuffix); static List<URI> findResources(String resourceLocation); static List<URI> findResources(String resourceLocation, Predicate<Path> filter); } | @Test public void loadResources_in_disk() throws IOException, URISyntaxException { List<URI> uris = ResourceUtil.findResourcesBySuffix("META-INF/spring", ".xml"); Assert.assertEquals(1, uris.size()); URI uri = uris.get(0); Assert.assertTrue("unexpected uri: " + uri, uri.toString().startsWith("file:")); Assert.assertTrue("unexpected uri: " + uri, uri.toString().endsWith("META-INF/spring/config.bean.xml")); } |
Log4jUtils { public static void init() throws Exception { init(Arrays.asList("classpath*:config/base/log4j.properties", "classpath*:config/log4j.properties")); } private Log4jUtils(); static void init(); static void init(String locationPattern); static void init(List<String> locationPatterns); static final String OUTPUT_CONFIG_ENABLED; static final String OUTPUT_CONFIG_ENABLED_TRUE; } | @Test public void init() { Holder<Boolean> propertiesLoaded = new Holder<>(false); Holder<Boolean> logConfigured = new Holder<>(false); Holder<Boolean> mergedFileWritten = new Holder<>(false); final Properties logProperties = new Properties(); logProperties.setProperty("paas.logs.file", "cse.log"); final ArrayList<Resource> logResList = new ArrayList<>(); new MockUp<PropertiesLoader>() { @Mock Properties load() { propertiesLoaded.value = true; return logProperties; } @Mock List<Resource> getFoundResList() { return logResList; } }; new MockUp<PropertyConfigurator>() { @Mock void configure(Properties properties) { logConfigured.value = true; Assert.assertSame(properties, logProperties); } }; new MockUp<Log4jUtils>() { @Mock void outputFile(List<Resource> resList, Properties properties) { mergedFileWritten.value = true; Assert.assertSame(logResList, resList); Assert.assertSame(logProperties, properties); } }; Assert.assertFalse(Deencapsulation.getField(Log4jUtils.class, "inited")); try { Log4jUtils.init(); } catch (Exception e) { fail(e.getMessage()); } Assert.assertTrue(Deencapsulation.getField(Log4jUtils.class, "inited")); Assert.assertTrue(propertiesLoaded.value); Assert.assertTrue(logConfigured.value); Assert.assertTrue(mergedFileWritten.value); }
@Test public void initOnMergedFileOutputDisabled() { Holder<Boolean> propertiesLoaded = new Holder<>(false); Holder<Boolean> logConfigured = new Holder<>(false); Holder<Boolean> mergedFileWritten = new Holder<>(false); final Properties logProperties = new Properties(); logProperties.setProperty("log4j.logger.outputConfig.enabled", "false"); final ArrayList<Resource> logResList = new ArrayList<>(); new MockUp<PropertiesLoader>() { @Mock Properties load() { propertiesLoaded.value = true; return logProperties; } }; new MockUp<PropertyConfigurator>() { @Mock void configure(Properties properties) { logConfigured.value = true; Assert.assertSame(properties, logProperties); } }; new MockUp<Log4jUtils>() { @Mock void outputFile(List<Resource> resList, Properties properties) { mergedFileWritten.value = true; Assert.assertSame(logResList, resList); Assert.assertSame(logProperties, properties); } }; Assert.assertFalse(Deencapsulation.getField(Log4jUtils.class, "inited")); try { Log4jUtils.init(); } catch (Exception e) { fail(e.getMessage()); } Assert.assertTrue(Deencapsulation.getField(Log4jUtils.class, "inited")); Assert.assertTrue(propertiesLoaded.value); Assert.assertTrue(logConfigured.value); Assert.assertFalse(mergedFileWritten.value); } |
AsyncUtils { public static <T> T toSync(CompletableFuture<T> future) { try { return future.get(); } catch (Throwable e) { rethrow(e.getCause()); return null; } } private AsyncUtils(); static CompletableFuture<T> tryCatch(Supplier<CompletableFuture<T>> supplier); static CompletableFuture<T> completeExceptionally(Throwable throwable); @SuppressWarnings("unchecked") static void rethrow(Throwable exception); static T toSync(CompletableFuture<T> future); } | @Test void should_convert_success_async_to_sync() { CompletableFuture<String> future = CompletableFuture.completedFuture("value"); assertThat(AsyncUtils.toSync(future)).isEqualTo("value"); } |
JvmUtils { public static Class<?> findMainClass() { String mainClass = null; String command = System.getProperty(SUN_JAVA_COMMAND); if (StringUtils.isNotEmpty(command)) { String mainClassOrJar = command.trim().split(" ")[0]; mainClass = readFromJar(mainClassOrJar); } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by manifest."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\".", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); } | @Test public void findMainClass_notExist() { Assert.assertNull(JvmUtils.findMainClass()); }
@Test public void findMainClass_existButEmpty() { System.setProperty(JvmUtils.SUN_JAVA_COMMAND, ""); Assert.assertNull(JvmUtils.findMainClass()); }
@Test public void findMainClass_invalid() { LogCollector logCollector = new LogCollector(); System.setProperty(JvmUtils.SUN_JAVA_COMMAND, "invalidCls"); Assert.assertNull(JvmUtils.findMainClass()); Assert.assertEquals("\"invalidCls\" is not a valid class.", logCollector.getEvents().get(0).getMessage()); logCollector.teardown(); }
@Test public void findMainClass_class_normal() { System.setProperty(JvmUtils.SUN_JAVA_COMMAND, TestJvmUtils.class.getName() + " arg"); Assert.assertEquals(TestJvmUtils.class, JvmUtils.findMainClass()); }
@Test public void findMainClass_jar_normal() throws Exception { URL url = PowerMockito.mock(URL.class); String command = "a.jar"; String manifestUri = "jar:file:" + new File(command).getAbsolutePath() + "!/" + JarFile.MANIFEST_NAME; PowerMockito.whenNew(URL.class).withParameterTypes(String.class) .withArguments(manifestUri).thenReturn(url); String content = String.format("Manifest-Version: 1.0\nMain-Class: %s\n", TestJvmUtils.class.getName()); InputStream inputStream = new ByteArrayInputStream(content.getBytes()); PowerMockito.when(url.openStream()).thenReturn(inputStream); System.setProperty(JvmUtils.SUN_JAVA_COMMAND, command + " arg"); Assert.assertEquals(TestJvmUtils.class, JvmUtils.findMainClass()); }
@Test public void findMainClass_jar_null() throws Exception { String content = "Manifest-Version: 1.0\n"; InputStream inputStream = new ByteArrayInputStream(content.getBytes()); URL url = PowerMockito.mock(URL.class); String command = "a.jar"; String manifestUri = "jar:file:/" + new File(command).getAbsolutePath() + "!/" + JarFile.MANIFEST_NAME; PowerMockito.whenNew(URL.class).withParameterTypes(String.class) .withArguments(manifestUri).thenReturn(url); PowerMockito.when(url.openStream()).thenReturn(inputStream); System.setProperty(JvmUtils.SUN_JAVA_COMMAND, command + " arg"); Assert.assertNull(JvmUtils.findMainClass()); }
@Test public void findMainClass_jar_readFailed() throws Exception { URL url = PowerMockito.mock(URL.class); String command = "a.jar"; String manifestUri = "jar:file:" + new File(command).getAbsolutePath() + "!/" + JarFile.MANIFEST_NAME; PowerMockito.whenNew(URL.class).withParameterTypes(String.class) .withArguments(manifestUri).thenReturn(url); PowerMockito.when(url.openStream()).thenThrow(new RuntimeExceptionWithoutStackTrace()); System.setProperty(JvmUtils.SUN_JAVA_COMMAND, command + " arg"); Assert.assertNull(JvmUtils.findMainClass()); } |
ServiceRegistryConfig { public ServiceRegistryConfig() { } ServiceRegistryConfig(); static ServiceRegistryConfig buildFromConfiguration(); String getTransport(); String getRegistryName(); ServiceRegistryConfig setRegistryName(String registryName); HttpVersion getHttpVersion(); ServiceRegistryConfig setHttpVersion(HttpVersion httpVersion); int getInstances(); ServiceRegistryConfig setInstances(int instances); boolean isSsl(); ServiceRegistryConfig setSsl(boolean ssl); String getClientName(); ServiceRegistryConfig setClientName(String clientName); String getWatchClientName(); ServiceRegistryConfig setWatchClientName(String watchClientName); ArrayList<IpPort> getIpPort(); ServiceRegistryConfig setIpPort(ArrayList<IpPort> ipPort); int getConnectionTimeout(); ServiceRegistryConfig setConnectionTimeout(int connectionTimeout); int getIdleConnectionTimeout(); ServiceRegistryConfig setIdleConnectionTimeout(int idleConnectionTimeout); int getRequestTimeout(); ServiceRegistryConfig setRequestTimeout(int requestTimeout); int getHeartBeatRequestTimeout(); ServiceRegistryConfig setHeartBeatRequestTimeout(int heartBeatRequestTimeout); int getHeartbeatInterval(); ServiceRegistryConfig setHeartbeatInterval(int heartbeatInterval); int getInstancePullInterval(); ServiceRegistryConfig setInstancePullInterval(int instancePullInterval); boolean isRegistryAutoDiscovery(); ServiceRegistryConfig setRegistryAutoDiscovery(boolean registryAutoDiscovery); int getResendHeartBeatTimes(); ServiceRegistryConfig setResendHeartBeatTimes(int resendHeartBeatTimes); boolean isAlwaysOverrideSchema(); ServiceRegistryConfig setAlwaysOverrideSchema(boolean alwaysOverrideSchema); boolean isPreferIpAddress(); ServiceRegistryConfig setPreferIpAddress(boolean preferIpAddress); boolean isWatch(); ServiceRegistryConfig setWatch(boolean watch); String getRegistryApiVersion(); ServiceRegistryConfig setRegistryApiVersion(String registryApiVersion); String getTenantName(); ServiceRegistryConfig setTenantName(String tenantName); String getDomainName(); ServiceRegistryConfig setDomainName(String domainName); String getAccessKey(); ServiceRegistryConfig setAccessKey(String accessKey); String getSecretKey(); ServiceRegistryConfig setSecretKey(String secretKey); Boolean isProxyEnable(); ServiceRegistryConfig setProxyEnable(Boolean proxyEnable); String getProxyHost(); ServiceRegistryConfig setProxyHost(String proxyHost); int getProxyPort(); ServiceRegistryConfig setProxyPort(int proxyPort); String getProxyUsername(); ServiceRegistryConfig setProxyUsername(String proxyUsername); String getProxyPasswd(); ServiceRegistryConfig setProxyPasswd(String proxyPasswd); List<AuthHeaderProvider> getAuthHeaderProviders(); ServiceRegistryConfig setAuthHeaderProviders(
List<AuthHeaderProvider> authHeaderProviders); ServiceRegistryConfig setServiceRegistryClientConstructor(
Function<ServiceRegistry, ServiceRegistryClient> serviceRegistryClientConstructor); ServiceRegistryClient createServiceRegistryClient(ServiceRegistry serviceRegistry); static final ServiceRegistryConfig INSTANCE; static final int DEFAULT_TIMEOUT_IN_SECONDS; static final int DEFAULT_REQUEST_TIMEOUT_IN_MS; static final int DEFAULT_REQUEST_HEARTBEAT_TIMEOUT_IN_MS; static final int DEFAULT_CHECK_INTERVAL_IN_S; static final int DEFAULT_CHECK_TIMES; static final String AUTH_ENABLED; static final String TENANT_ACCESS_KEY; static final String TENANT_SECRET_KEY; static final String REGISTRY_API_VERSION; static final String TENANT_NAME; static final String DOMAIN_NAME; static final String NO_TENANT; static final String NO_DOMAIN; static final String VERTICLE_INSTANCES; static final String EVENT_LOOP_POOL_SIZE; static final String WORKER_POOL_SIZE; } | @Test public void testServiceRegistryConfig() { ServiceRegistryConfig oConfig = new ServiceRegistryConfigBuilder().build(); Assert.assertNull(oConfig.getAccessKey()); Assert.assertEquals(1000, oConfig.getConnectionTimeout()); Assert.assertNotEquals(null, oConfig.getHeartbeatInterval()); Assert.assertEquals("HTTP_1_1", oConfig.getHttpVersion().name()); Assert.assertEquals("rest", oConfig.getTransport()); Assert.assertEquals(1, oConfig.getInstances()); Assert.assertTrue(oConfig.isSsl()); Assert.assertEquals(30000, oConfig.getRequestTimeout()); Assert.assertEquals(3000, oConfig.getHeartBeatRequestTimeout()); Assert.assertNotEquals(null, oConfig.getResendHeartBeatTimes()); Assert.assertFalse(oConfig.isPreferIpAddress()); Assert.assertTrue(oConfig.isWatch()); Assert.assertEquals(ServiceRegistryConfig.NO_TENANT, oConfig.getTenantName()); Assert.assertNull(oConfig.getSecretKey()); List<IpPort> ipPorts = oConfig.getIpPort(); Assert.assertEquals("127.0.0.1:80", ipPorts.get(0).toString()); Assert.assertEquals("127.0.0.1:443", ipPorts.get(1).toString()); Assert.assertFalse(oConfig.isProxyEnable()); Assert.assertEquals("127.0.0.1", oConfig.getProxyHost()); Assert.assertEquals(8080, oConfig.getProxyPort()); Assert.assertNull(oConfig.getProxyUsername()); Assert.assertNull(oConfig.getProxyPasswd()); } |
JvmUtils { public static Class<?> findMainClassByStackTrace() { String mainClass = null; StackTraceElement[] stackTrace = new RuntimeException().getStackTrace(); if (stackTrace != null && stackTrace.length > 0) { for (StackTraceElement stackTraceElement : stackTrace) { if ("main".equals(stackTraceElement.getMethodName())) { mainClass = stackTraceElement.getClassName(); break; } } } if(StringUtils.isEmpty(mainClass)){ LOGGER.info("Can't found main class by stackTrace."); return null; } try { Class<?> cls = Class.forName(mainClass); LOGGER.info("Found main class \"{}\" by stackTrace.", mainClass); return cls; } catch (Throwable e) { LOGGER.warn("\"{}\" is not a valid class.", mainClass, e); return null; } } private JvmUtils(); static Class<?> findMainClassByStackTrace(); static Class<?> findMainClass(); static ClassLoader correctClassLoader(ClassLoader classLoader); static ClassLoader findClassLoader(); } | @Test public void findMainClassByStackTrace_normal() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(new StackTraceElement[]{ new StackTraceElement("declaring.class.fileName", "methodName", "fileName", 100), new StackTraceElement("java.lang.String", "main", "fileName", 120) }); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertEquals(String.class, JvmUtils.findMainClassByStackTrace()); }
@Test public void findMainClassByStackTrace_invalidClass() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(new StackTraceElement[]{ new StackTraceElement("declaring.class.fileName", "methodName", "fileName", 100), new StackTraceElement("InvalidClass", "main", "fileName", 120) }); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertNull(JvmUtils.findMainClassByStackTrace()); }
@Test public void findMainClassByStackTrace_withoutMainMethod() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(new StackTraceElement[]{ new StackTraceElement("declaring.class.fileName", "methodName", "fileName", 100), new StackTraceElement("InvalidClass", "methodName", "fileName", 120) }); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertNull(JvmUtils.findMainClassByStackTrace()); }
@Test public void findMainClassByStackTrace_emptyStackTrace() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(new StackTraceElement[]{}); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertNull(JvmUtils.findMainClassByStackTrace()); }
@Test public void findMainClassByStackTrace_nullStackTrace() throws Exception{ RuntimeException re = PowerMockito.mock(RuntimeException.class); PowerMockito.when(re.getStackTrace()).thenReturn(null); PowerMockito.whenNew(RuntimeException.class).withNoArguments().thenReturn(re); Assert.assertNull(JvmUtils.findMainClassByStackTrace()); } |
BeanUtils { public static Class<?> getImplClassFromBean(Object bean) { return AopProxyUtils.ultimateTargetClass(bean); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; } | @Test public void test() { Intf target = new Impl(); AspectJProxyFactory factory = new AspectJProxyFactory(target); MyAspect aspect = new MyAspect(); factory.addAspect(aspect); Intf proxy = factory.getProxy(); Assert.assertEquals(Impl.class, BeanUtils.getImplClassFromBean(proxy)); Assert.assertEquals(Impl.class, BeanUtils.getImplClassFromBean(new Impl())); }
@Test public void testGetImplClassFromBeanFromCglib(){ TestBean testBeanByCGLIB = new TestBean$$TestBeanByCGLIB$$e1a36bab(); Class<?> generatedClass = BeanUtils.getImplClassFromBean(testBeanByCGLIB); Assert.assertNotNull(generatedClass); Assert.assertEquals(TestBean.class, generatedClass); } |
BeanUtils { public static void prepareServiceCombScanPackage() { Set<String> scanPackags = new LinkedHashSet<>(); String exists = System.getProperty(SCB_SCAN_PACKAGE); if (exists != null) { for (String exist : exists.trim().split(",")) { if (!exist.isEmpty()) { addItem(scanPackags, exist.trim()); } } } addItem(scanPackags, SCB_PACKAGE); for (Class<?> mainClass : new Class<?>[] {JvmUtils.findMainClass(), JvmUtils.findMainClassByStackTrace()}) { if (mainClass != null) { String pkg = mainClass.getPackage().getName(); addItem(scanPackags, pkg); } } String scbScanPackages = StringUtils.join(scanPackags, ","); System.setProperty(SCB_SCAN_PACKAGE, scbScanPackages); LOGGER.info("Scb scan package list: " + scbScanPackages); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; } | @Test public void prepareServiceCombScanPackage_noExist_noMain() { System.clearProperty(BeanUtils.SCB_SCAN_PACKAGE); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = null; JvmUtils.findMainClassByStackTrace(); result = null; } }; BeanUtils.prepareServiceCombScanPackage(); Assert.assertEquals("org.apache.servicecomb", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); }
@Test public void prepareServiceCombScanPackage_noExist_scbMain() { System.clearProperty(BeanUtils.SCB_SCAN_PACKAGE); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = TestBeanUtils.class; JvmUtils.findMainClassByStackTrace(); result = TestBeanUtils.class; } }; BeanUtils.prepareServiceCombScanPackage(); Assert.assertEquals("org.apache.servicecomb", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); }
@Test public void prepareServiceCombScanPackage_noExist_otherMain() { System.clearProperty(BeanUtils.SCB_SCAN_PACKAGE); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = String.class; JvmUtils.findMainClassByStackTrace(); result = BigDecimal.class; } }; BeanUtils.prepareServiceCombScanPackage(); Assert.assertEquals("org.apache.servicecomb,java.lang,java.math", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); }
@Test public void prepareServiceCombScanPackage_exist() { System.setProperty(BeanUtils.SCB_SCAN_PACKAGE, "a.b,,c.d"); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = null; JvmUtils.findMainClassByStackTrace(); result = null; } }; BeanUtils.prepareServiceCombScanPackage(); Assert.assertEquals("a.b,c.d,org.apache.servicecomb", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); } |
RegistryUtils { public static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache) { MicroserviceInstances microserviceInstances = new MicroserviceInstances(); switch (microserviceCache.getStatus()) { case SERVICE_NOT_FOUND: microserviceInstances.setMicroserviceNotExist(true); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(""); microserviceInstances.setInstancesResponse(null); return microserviceInstances; case NO_CHANGE: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(false); microserviceInstances.setRevision(microserviceCache.getRevisionId()); return microserviceInstances; case REFRESHED: microserviceInstances.setMicroserviceNotExist(false); microserviceInstances.setNeedRefresh(true); microserviceInstances.setRevision(microserviceCache.getRevisionId()); FindInstancesResponse findInstancesResponse = new FindInstancesResponse(); findInstancesResponse.setInstances(new ArrayList<>(microserviceCache.getInstances())); microserviceInstances.setInstancesResponse(findInstancesResponse); return microserviceInstances; default: return null; } } private RegistryUtils(); static synchronized void init(); static void run(); static void destroy(); static ServiceRegistry getServiceRegistry(); static void setServiceRegistry(ServiceRegistry serviceRegistry); @Deprecated static ServiceRegistryClient getServiceRegistryClient(); static String getAppId(); static Microservice getMicroservice(); static List<Microservice> getAllMicroservices(); static MicroserviceInstance getMicroserviceInstance(); static List<MicroserviceInstance> findServiceInstance(String appId, String serviceName,
String versionRule); static boolean updateInstanceProperties(Map<String, String> instanceProperties); static Microservice getMicroservice(String microserviceId); static MicroserviceInstances findServiceInstances(String appId, String serviceName,
String versionRule); static MicroserviceInstances convertCacheToMicroserviceInstances(MicroserviceCache microserviceCache); static String calcSchemaSummary(String schemaContent); static String getAggregatedSchema(String microserviceId, String schemaId); static Microservice getAggregatedRemoteMicroservice(String microserviceId); static T getResultFromFirstValidServiceRegistry(Function<ServiceRegistry, T> action); static void executeOnEachServiceRegistry(Consumer<ServiceRegistry> action); static void addExtraServiceRegistry(ServiceRegistry serviceRegistry); static void validateRegistryName(String name); } | @Test public void convertCacheToMicroserviceInstances() { MockedMicroserviceCache microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.CLIENT_ERROR); MicroserviceInstances microserviceInstances = RegistryUtils .convertCacheToMicroserviceInstances(microserviceCache); Assert.assertNull(microserviceInstances); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.SETTING_CACHE_ERROR); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertNull(microserviceInstances); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.INIT); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertNull(microserviceInstances); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.SERVICE_NOT_FOUND); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertTrue(microserviceInstances.isMicroserviceNotExist()); Assert.assertFalse(microserviceInstances.isNeedRefresh()); Assert.assertEquals("", microserviceInstances.getRevision()); Assert.assertNull(microserviceInstances.getInstancesResponse()); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.REFRESHED); microserviceCache.setRevisionId("0166f3c18702617d5e55cf911e4e412cc8760dab"); MicroserviceInstance microserviceInstance = new MicroserviceInstance(); microserviceCache.setInstances(Collections.singletonList(microserviceInstance)); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertFalse(microserviceInstances.isMicroserviceNotExist()); Assert.assertTrue(microserviceInstances.isNeedRefresh()); Assert.assertEquals("0166f3c18702617d5e55cf911e4e412cc8760dab", microserviceInstances.getRevision()); Assert.assertEquals(1, microserviceInstances.getInstancesResponse().getInstances().size()); Assert.assertSame(microserviceInstance, microserviceInstances.getInstancesResponse().getInstances().get(0)); microserviceCache = new MockedMicroserviceCache(); microserviceCache.setStatus(MicroserviceCacheStatus.NO_CHANGE); microserviceCache.setRevisionId("0166f3c18702617d5e55cf911e4e412cc8760dab"); microserviceInstances = RegistryUtils.convertCacheToMicroserviceInstances(microserviceCache); Assert.assertFalse(microserviceInstances.isMicroserviceNotExist()); Assert.assertFalse(microserviceInstances.isNeedRefresh()); Assert.assertEquals("0166f3c18702617d5e55cf911e4e412cc8760dab", microserviceInstances.getRevision()); Assert.assertNull(microserviceInstances.getInstancesResponse()); } |
BeanUtils { public static void init() { init(DEFAULT_BEAN_RESOURCE); } private BeanUtils(); static void init(); static void init(String... configLocations); static void addBeanLocation(Set<String> locationSet, String... location); static void addBeanLocation(Set<String> locationSet, String location); static void prepareServiceCombScanPackage(); static ApplicationContext getContext(); static void setContext(ApplicationContext applicationContext); @SuppressWarnings("unchecked") static T getBean(String name); static Map<String, T> getBeansOfType(Class<T> type); static Class<?> getImplClassFromBean(Object bean); static final String DEFAULT_BEAN_CORE_RESOURCE; static final String DEFAULT_BEAN_NORMAL_RESOURCE; static final String[] DEFAULT_BEAN_RESOURCE; static final String SCB_SCAN_PACKAGE; } | @Test public void init(@Mocked ClassPathXmlApplicationContext context) { System.clearProperty(BeanUtils.SCB_SCAN_PACKAGE); new Expectations(JvmUtils.class) { { JvmUtils.findMainClass(); result = TestBeanUtils.class; JvmUtils.findMainClassByStackTrace(); result = TestBeanUtils.class; } }; BeanUtils.init(); Assert.assertEquals("org.apache.servicecomb", System.getProperty(BeanUtils.SCB_SCAN_PACKAGE)); } |
VersionedCache { public <T extends VersionedCache> T autoCacheVersion() { this.cacheVersion = VERSION.incrementAndGet(); return (T) this; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); } | @Test public void autoCacheVersion() { VersionedCache cache = new VersionedCache().autoCacheVersion(); Assert.assertEquals(VERSION.get(), cache.cacheVersion()); } |
VersionedCache { public String name() { return name; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); } | @Test public void setName() { VersionedCache cache = new VersionedCache().name("n"); Assert.assertEquals("n", cache.name()); } |
VersionedCache { public boolean isExpired(VersionedCache newCache) { return newCache.cacheVersion - cacheVersion > 0; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); } | @Test public void isExpired() { VersionedCache cacheOld = new VersionedCache().autoCacheVersion(); VersionedCache cacheNew = new VersionedCache().autoCacheVersion(); Assert.assertTrue(cacheOld.isExpired(cacheNew)); Assert.assertFalse(cacheOld.isExpired(cacheOld)); Assert.assertFalse(cacheNew.isExpired(cacheOld)); } |
VersionedCache { public boolean isSameVersion(VersionedCache newCache) { return newCache.cacheVersion == cacheVersion; } int cacheVersion(); T autoCacheVersion(); T cacheVersion(int cacheVersion); String name(); T name(String name); T subName(VersionedCache parent, String subName); T data(); Map<K, V> mapData(); Collection<T> collectionData(); T[] arrayData(); T data(Object data); boolean isExpired(VersionedCache newCache); boolean isSameVersion(VersionedCache newCache); boolean isEmpty(); } | @Test public void isSameVersion() { VersionedCache cacheOld = new VersionedCache().autoCacheVersion(); VersionedCache cacheNew = new VersionedCache().autoCacheVersion(); VersionedCache cacheSame = new VersionedCache().cacheVersion(cacheNew.cacheVersion()); Assert.assertFalse(cacheOld.isSameVersion(cacheNew)); Assert.assertTrue(cacheSame.isSameVersion(cacheNew)); } |
PaasNamespaceHandler extends NamespaceHandlerSupport { public void init() { Properties properties = null; try { properties = PaaSResourceUtils.loadMergedProperties(NAMESPACE_RES); } catch (Exception e) { LOGGER.error("Failed to load namespace handler define, {}, {}", NAMESPACE_RES, FortifyUtils.getErrorInfo(e)); return; } for (Entry<Object, Object> entry : properties.entrySet()) { String className = entry.getValue().toString(); try { Class<?> clazz = Class.forName(className); Object instance = clazz.newInstance(); registerBeanDefinitionParser(entry.getKey().toString(), (BeanDefinitionParser) instance); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) { LOGGER.info("Failed to create BeanDefinitionParser instance of {}", className); } } } void init(); } | @Test public void testInit() { boolean status = false; try { paasNamespaceHandler.init(); } catch (Exception e) { status = true; } Assert.assertFalse(status); } |
DynamicObject { @JsonAnyGetter public Map<String, Object> getDynamic() { return dynamic; } @JsonAnyGetter Map<String, Object> getDynamic(); @SuppressWarnings("unchecked") T getDynamic(String key); void setDynamic(Map<String, Object> dynamic); @JsonAnySetter DynamicObject putDynamic(String key, Object value); } | @Test void should_support_json_encode_decode() { Map<String, Object> map = new HashMap<>(); map.put("k", "v"); DynamicObject dynamicObject = DatabindCodec.mapper().convertValue(map, DynamicObject.class); assertThat(dynamicObject.getDynamic()).isNotSameAs(map); assertThat(dynamicObject.getDynamic()).isEqualTo(map); assertThat(Json.encode(dynamicObject)).isEqualTo("{\"k\":\"v\"}"); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public boolean registerSchema(String microserviceId, String schemaId, String schemaContent) { Holder<ResponseWrapper> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); try { CreateSchemaRequest request = new CreateSchemaRequest(); request.setSchema(schemaContent); request.setSummary(RegistryUtils.calcSchemaSummary(schemaContent)); byte[] body = JsonUtils.writeValueAsBytes(request); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.put(ipPort, String.format(Const.REGISTRY_API.MICROSERVICE_SCHEMA, microserviceId, schemaId), new RequestParam().setBody(body), syncHandlerEx(countDownLatch, holder)); countDownLatch.await(); if (holder.value == null) { LOGGER.error("Register schema {}/{} failed.", microserviceId, schemaId); return false; } if (!Status.Family.SUCCESSFUL.equals(Status.Family.familyOf(holder.value.response.statusCode()))) { LOGGER.error("Register schema {}/{} failed, statusCode: {}, statusMessage: {}, description: {}.", microserviceId, schemaId, holder.value.response.statusCode(), holder.value.response.statusMessage(), holder.value.bodyBuffer.toString()); return false; } LOGGER.info("register schema {}/{} success.", microserviceId, schemaId); return true; } catch (Exception e) { LOGGER.error("register schema {}/{} fail.", microserviceId, schemaId, e); } return false; } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void testRegisterSchemaNoResponse() { new MockUp<RestClientUtil>() { @Mock void put(IpPort ipPort, String uri, RequestParam requestParam, Handler<RestResponse> responseHandler) { } }; new RegisterSchemaTester() { void doRun(java.util.List<LoggingEvent> events) { oClient.registerSchema("msid", "schemaId", "content"); Assert.assertEquals("Register schema msid/schemaId failed.", events.get(0).getMessage()); } }.run(); }
@Test public void testRegisterSchemaException() { new MockUp<RestClientUtil>() { @Mock void put(IpPort ipPort, String uri, RequestParam requestParam, Handler<RestResponse> responseHandler) { } }; InterruptedException e = new InterruptedException(); new MockUp<CountDownLatch>() { @Mock public void await() throws InterruptedException { throw e; } }; new RegisterSchemaTester() { void doRun(java.util.List<LoggingEvent> events) { oClient.registerSchema("msid", "schemaId", "content"); Assert.assertEquals( "register schema msid/schemaId fail.", events.get(0).getMessage()); Assert.assertEquals(e, events.get(0).getThrowableInformation().getThrowable()); } }.run(); }
@Test public void testRegisterSchemaErrorResponse() { new MockUp<ServiceRegistryClientImpl>() { @Mock Handler<RestResponse> syncHandlerEx(CountDownLatch countDownLatch, Holder<ResponseWrapper> holder) { return restResponse -> { HttpClientResponse response = Mockito.mock(HttpClientResponse.class); Mockito.when(response.statusCode()).thenReturn(400); Mockito.when(response.statusMessage()).thenReturn("client error"); Buffer bodyBuffer = Buffer.buffer(); bodyBuffer.appendString("too big"); ResponseWrapper responseWrapper = new ResponseWrapper(); responseWrapper.response = response; responseWrapper.bodyBuffer = bodyBuffer; holder.value = responseWrapper; }; } }; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { responseHandler.handle(null); } }; new RegisterSchemaTester() { void doRun(java.util.List<LoggingEvent> events) { oClient.registerSchema("msid", "schemaId", "content"); Assert.assertEquals( "Register schema msid/schemaId failed, statusCode: 400, statusMessage: client error, description: too big.", events.get(0).getMessage()); } }.run(); }
@Test public void testRegisterSchemaSuccess() { new MockUp<ServiceRegistryClientImpl>() { @Mock Handler<RestResponse> syncHandlerEx(CountDownLatch countDownLatch, Holder<ResponseWrapper> holder) { return restResponse -> { HttpClientResponse response = Mockito.mock(HttpClientResponse.class); Mockito.when(response.statusCode()).thenReturn(200); ResponseWrapper responseWrapper = new ResponseWrapper(); responseWrapper.response = response; holder.value = responseWrapper; }; } }; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { responseHandler.handle(null); } }; new RegisterSchemaTester() { void doRun(java.util.List<LoggingEvent> events) { oClient.registerSchema("msid", "schemaId", "content"); Assert.assertEquals( "register schema msid/schemaId success.", events.get(0).getMessage()); } }.run(); } |
SSLManager { public static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom) { SSLContext context = createSSLContext(option, custom); SSLEngine engine = context.createSSLEngine(); engine.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = engine.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); engine.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); engine.setNeedClientAuth(option.isAuthPeer()); return engine; } private SSLManager(); static SSLContext createSSLContext(SSLOption option, SSLCustom custom); static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom, String peerHost, int peerPort); static SSLServerSocket createSSLServerSocket(SSLOption option,
SSLCustom custom); static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom); static String[] getEnalbedCiphers(String enabledCiphers); } | @Test public void testCreateSSLEngine() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; SSLEngine aSSLEngine = SSLManager.createSSLEngine(option, custom); Assert.assertEquals(false, aSSLEngine.getUseClientMode()); Assert.assertNotNull(aSSLEngine); }
@Test public void testCreateSSLEnginewithPort() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; int port = 39093; String peerHost = "host1"; SSLEngine aSSLEngine = SSLManager.createSSLEngine(option, custom, peerHost, port); Assert.assertNotNull(aSSLEngine); Assert.assertEquals("host1", aSSLEngine.getPeerHost().toString()); } |
SSLManager { public static SSLContext createSSLContext(SSLOption option, SSLCustom custom) { try { String keyStoreName = custom.getFullPath(option.getKeyStore()); KeyManager[] keymanager; if (keyStoreName != null && new File(keyStoreName).exists()) { char[] keyStoreValue = custom.decode(option.getKeyStoreValue().toCharArray()); KeyStore keyStore = KeyStoreUtil.createKeyStore(keyStoreName, option.getKeyStoreType(), keyStoreValue); keymanager = KeyStoreUtil.createKeyManagers(keyStore, keyStoreValue); } else { keymanager = null; } String trustStoreName = custom.getFullPath(option.getTrustStore()); TrustManager[] trustManager; if (trustStoreName != null && new File(trustStoreName).exists()) { char[] trustStoreValue = custom.decode(option.getTrustStoreValue().toCharArray()); KeyStore trustStore = KeyStoreUtil.createKeyStore(trustStoreName, option.getTrustStoreType(), trustStoreValue); trustManager = KeyStoreUtil.createTrustManagers(trustStore); } else { trustManager = new TrustManager[] {new TrustAllManager()}; } TrustManager[] wrapped = new TrustManager[trustManager.length]; for (int i = 0; i < trustManager.length; i++) { wrapped[i] = new TrustManagerExt((X509ExtendedTrustManager) trustManager[i], option, custom); } SSLContext context = SSLContext.getInstance("TLS"); context.init(keymanager, wrapped, new SecureRandom()); return context; } catch (NoSuchAlgorithmException e) { throw new IllegalArgumentException("NoSuchAlgorithmException." + e.getMessage()); } catch (KeyManagementException e) { throw new IllegalArgumentException("KeyManagementException." + e.getMessage()); } } private SSLManager(); static SSLContext createSSLContext(SSLOption option, SSLCustom custom); static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom, String peerHost, int peerPort); static SSLServerSocket createSSLServerSocket(SSLOption option,
SSLCustom custom); static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom); static String[] getEnalbedCiphers(String enabledCiphers); } | @Test public void testCreateSSLContextException() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws NoSuchAlgorithmException { throw new NoSuchAlgorithmException(); } }; try { SSLContext context = SSLManager.createSSLContext(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } }
@Test public void testCreateSSLContextKeyManagementException() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws KeyManagementException { throw new KeyManagementException(); } }; try { SSLContext context = SSLManager.createSSLContext(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } } |
SSLManager { public static SSLServerSocket createSSLServerSocket(SSLOption option, SSLCustom custom) { try { SSLContext context = createSSLContext(option, custom); SSLServerSocketFactory factory = context.getServerSocketFactory(); SSLServerSocket socket = (SSLServerSocket) factory.createServerSocket(); socket.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = socket.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); socket.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); socket.setNeedClientAuth(option.isAuthPeer()); return socket; } catch (UnknownHostException e) { throw new IllegalArgumentException("unkown host"); } catch (IOException e) { throw new IllegalArgumentException("unable create socket"); } } private SSLManager(); static SSLContext createSSLContext(SSLOption option, SSLCustom custom); static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom, String peerHost, int peerPort); static SSLServerSocket createSSLServerSocket(SSLOption option,
SSLCustom custom); static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom); static String[] getEnalbedCiphers(String enabledCiphers); } | @Test public void testCreateSSLServerSocketException() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws UnknownHostException { throw new UnknownHostException(); } }; try { SSLServerSocket context = SSLManager.createSSLServerSocket(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } }
@Test public void testCreateSSLServerSocketIOException() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws IOException { throw new IOException(); } }; try { SSLServerSocket context = SSLManager.createSSLServerSocket(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } } |
SSLManager { public static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom) { try { SSLContext context = createSSLContext(option, custom); SSLSocketFactory facroty = context.getSocketFactory(); SSLSocket socket = (SSLSocket) facroty.createSocket(); socket.setEnabledProtocols(option.getProtocols().split(",")); String[] supported = socket.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); socket.setEnabledCipherSuites(getEnabledCiphers(supported, eanbled)); return socket; } catch (UnknownHostException e) { throw new IllegalArgumentException("unkown host"); } catch (IOException e) { throw new IllegalArgumentException("unable create socket"); } } private SSLManager(); static SSLContext createSSLContext(SSLOption option, SSLCustom custom); static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom, String peerHost, int peerPort); static SSLServerSocket createSSLServerSocket(SSLOption option,
SSLCustom custom); static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom); static String[] getEnalbedCiphers(String enabledCiphers); } | @Test public void testCreateSSLSocketException() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws UnknownHostException { throw new UnknownHostException(); } }; try { SSLSocket context = SSLManager.createSSLSocket(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } }
@Test public void testCreateSSLSocketIOException() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; new MockUp<SSLContext>() { @Mock public final SSLContext getInstance(String type) throws IOException { throw new IOException(); } }; try { SSLSocket context = SSLManager.createSSLSocket(option, custom); Assert.assertNotNull(context); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } } |
SSLManager { public static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom) { SSLContext context = createSSLContext(option, custom); SSLSocketFactory factory = context.getSocketFactory(); String[] supported = factory.getSupportedCipherSuites(); String[] eanbled = option.getCiphers().split(","); return new SSLSocketFactoryExt(factory, getEnabledCiphers(supported, eanbled), option.getProtocols().split(",")); } private SSLManager(); static SSLContext createSSLContext(SSLOption option, SSLCustom custom); static SSLSocketFactory createSSLSocketFactory(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom); static SSLEngine createSSLEngine(SSLOption option, SSLCustom custom, String peerHost, int peerPort); static SSLServerSocket createSSLServerSocket(SSLOption option,
SSLCustom custom); static SSLSocket createSSLSocket(SSLOption option, SSLCustom custom); static String[] getEnalbedCiphers(String enabledCiphers); } | @Test public void testCreateSSLSocketFactory() { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); SSLCustom custom = new SSLCustom() { @Override public String getFullPath(String filename) { return DIR + "/ssl/" + filename; } @Override public char[] decode(char[] encrypted) { return encrypted; } }; SSLSocketFactory aSSLSocketFactory = SSLManager.createSSLSocketFactory(option, custom); Assert.assertNotNull(aSSLSocketFactory.getDefaultCipherSuites()[0]); } |
SSLOption { public static SSLOption build(String optionfile) { File file = new File(optionfile); if (!file.isFile()) { throw new IllegalArgumentException("Bad file name."); } try { SSLOption option = new SSLOption(); option.load(file.getCanonicalPath()); return option; } catch (IOException e) { throw new IllegalArgumentException("Bad file name."); } } String getEngine(); void setEngine(String engine); void setProtocols(String protocols); void setCiphers(String ciphers); void setAuthPeer(boolean authPeer); void setCheckCNHost(boolean checkCNHost); void setCheckCNWhite(boolean checkCNWhite); void setCheckCNWhiteFile(String checkCNWhiteFile); void setAllowRenegociate(boolean allowRenegociate); void setStorePath(String storePath); void setTrustStore(String trustStore); void setTrustStoreType(String trustStoreType); void setTrustStoreValue(String trustStoreValue); void setKeyStore(String keyStore); void setKeyStoreType(String keyStoreType); void setKeyStoreValue(String keyStoreValue); void setCrl(String crl); String getProtocols(); String getCiphers(); boolean isAuthPeer(); boolean isCheckCNHost(); boolean isCheckCNWhite(); String getCheckCNWhiteFile(); boolean isAllowRenegociate(); String getStorePath(); String getTrustStore(); String getTrustStoreType(); String getTrustStoreValue(); String getKeyStore(); String getKeyStoreType(); String getKeyStoreValue(); String getCrl(); static SSLOption build(String optionfile); static SSLOption build(InputStream inputStream); static String getStringProperty(ConcurrentCompositeConfiguration configSource, String defaultValue,
String... keys); static SSLOption buildFromYaml(String tag, ConcurrentCompositeConfiguration configSource); static SSLOption buildFromYaml(String tag); String getSslCustomClass(); void setSslCustomClass(String sslCustomClass); static final String DEFAULT_CIPHERS; } | @SuppressWarnings("unused") @Test public void testSSLOptionNull() { try { SSLOption option = SSLOption.build(DIR + "/servers.ssl.properties"); } catch (IllegalArgumentException e) { Assert.assertEquals("Bad file name.", e.getMessage()); } }
@Test public void testBuildException() { new MockUp<File>() { @Mock public String getCanonicalPath() throws IOException { throw new IOException(); } }; try { SSLOption option = SSLOption.build(DIR + "/server.ssl.properties"); Assert.assertNotNull(option); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } }
@Test public void testBuildInputStream() { try { URL url = this.getClass().getResource("/server.ssl.properties"); InputStream inputStream = url.openStream(); SSLOption option = SSLOption.build(inputStream); Assert.assertNotNull(option); } catch (Exception e) { Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } } |
CertificateUtil { public static Set<String> getCN(X509Certificate cert) { Set<String> names = new HashSet<>(); String subjectDN = cert.getSubjectX500Principal().getName(); String[] pairs = subjectDN.split(","); for (String p : pairs) { String[] kv = p.split("="); if (kv.length == 2 && kv[0].equals("CN")) { names.add(kv[1]); } } try { Collection<List<?>> collection = cert.getSubjectAlternativeNames(); if (collection != null) { for (List<?> list : collection) { if (list.size() == 2) { Object key = list.get(0); Object value = list.get(1); if (key instanceof Integer && value instanceof String) { int intKey = ((Integer) key).intValue(); String strValue = (String) value; if (intKey == SUBALTNAME_DNSNAME || intKey == SUBALTNAME_IPADDRESS) { names.add(strValue); } } } } } } catch (CertificateParsingException e) { throw new IllegalArgumentException("can not read AlternativeNames."); } return names; } private CertificateUtil(); static X509Certificate findOwner(X509Certificate[] cerChain); static Set<String> getCN(X509Certificate cert); } | @Test public void testGetCN(@Mocked X500Principal aX500Principal, @Mocked MyX509Certificate myX509Certificate) { new Expectations() { { aX500Principal.getName(); result = "CN=Test1234"; myX509Certificate.getSubjectX500Principal(); result = aX500Principal; } }; MyX509Certificate xxmyX509Certificate = new MyX509Certificate(); Set<String> strExpect = CertificateUtil.getCN(xxmyX509Certificate); Assert.assertEquals(true, strExpect.contains("Test1234")); }
@Test public void testGetCNException(@Mocked X500Principal aX500Principal, @Mocked MyX509Certificate myX509Certificate) { new Expectations() { { aX500Principal.getName(); result = "NOCN=Test1234"; myX509Certificate.getSubjectX500Principal(); result = aX500Principal; } }; MyX509Certificate xxmyX509Certificate = new MyX509Certificate(); try { Set<String> strExpect = CertificateUtil.getCN(xxmyX509Certificate); Assert.assertEquals(strExpect.size(), 0); } catch (IllegalArgumentException e) { Assert.assertNotNull(null); } } |
CertificateUtil { public static X509Certificate findOwner(X509Certificate[] cerChain) { X509Certificate[] sorted = sort(cerChain); return sorted[sorted.length - 1]; } private CertificateUtil(); static X509Certificate findOwner(X509Certificate[] cerChain); static Set<String> getCN(X509Certificate cert); } | @Test public void testFindOwner(@Mocked X500Principal aX500Principal1, @Mocked X500Principal aX500Principal2, @Mocked MyX509Certificate myX509Certificate) { new Expectations() { { aX500Principal1.getName(); result = "Huawei"; } { aX500Principal2.getName(); result = "Huawei"; } { myX509Certificate.getSubjectX500Principal(); result = aX500Principal1; myX509Certificate.getIssuerX500Principal(); result = aX500Principal2; } }; MyX509Certificate myX509Certificate1 = new MyX509Certificate(); MyX509Certificate myX509Certificate2 = new MyX509Certificate(); MyX509Certificate[] xxmyX509Certificate = new MyX509Certificate[2]; xxmyX509Certificate[0] = myX509Certificate1; xxmyX509Certificate[1] = myX509Certificate2; X509Certificate aX509Certificate = CertificateUtil.findOwner(xxmyX509Certificate); Assert.assertNull(aX509Certificate); }
@Test public void testFindRootCAException(@Mocked X500Principal aX500Principal1, @Mocked X500Principal aX500Principal2, @Mocked MyX509Certificate myX509Certificate) { new Expectations() { { aX500Principal1.getName(); result = "Huawei1"; } { aX500Principal2.getName(); result = "Huawei3"; } { myX509Certificate.getSubjectX500Principal(); result = aX500Principal1; myX509Certificate.getIssuerX500Principal(); result = aX500Principal2; } }; MyX509Certificate myX509Certificate1 = new MyX509Certificate(); MyX509Certificate myX509Certificate2 = new MyX509Certificate(); MyX509Certificate[] xxmyX509Certificate = new MyX509Certificate[2]; xxmyX509Certificate[0] = myX509Certificate1; xxmyX509Certificate[1] = myX509Certificate2; try { X509Certificate aX509Certificate = CertificateUtil.findOwner(xxmyX509Certificate); Assert.assertNull(aX509Certificate); } catch (IllegalArgumentException e) { Assert.assertEquals("bad certificate chain: no root CA.", e.getMessage()); } } |
TrustManagerExt extends X509ExtendedTrustManager { @Override public X509Certificate[] getAcceptedIssuers() { return trustManager.getAcceptedIssuers(); } TrustManagerExt(X509ExtendedTrustManager manager, SSLOption option,
SSLCustom custom); @Override void checkClientTrusted(X509Certificate[] chain, String authType); @Override void checkServerTrusted(X509Certificate[] chain, String authType); @Override X509Certificate[] getAcceptedIssuers(); @Override void checkClientTrusted(X509Certificate[] chain, String authType,
Socket socket); @Override void checkClientTrusted(X509Certificate[] chain, String authType,
SSLEngine engine); @Override void checkServerTrusted(X509Certificate[] chain, String authType,
Socket socket); @Override void checkServerTrusted(X509Certificate[] chain, String authType,
SSLEngine engine); } | @SuppressWarnings("unused") @Test public void testConstructor() { String keyStoreName = custom.getFullPath(option.getKeyStore()); char[] keyStoreValue = custom.decode(option.getKeyStoreValue().toCharArray()); String trustStoreName = custom.getFullPath(option.getTrustStore()); char[] trustStoreValue = custom.decode(option.getTrustStoreValue().toCharArray()); KeyStore trustStore = KeyStoreUtil.createKeyStore(trustStoreName, option.getTrustStoreType(), trustStoreValue); TrustManager[] trustManager = KeyStoreUtil.createTrustManagers(trustStore); TrustManagerExt trustManagerExt = new TrustManagerExt((X509ExtendedTrustManager) trustManager[0], option, custom); Assert.assertEquals(3, trustManagerExt.getAcceptedIssuers()[0].getVersion()); Assert.assertNotNull(trustManagerExt); } |
TrustManagerExt extends X509ExtendedTrustManager { @Override public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { if (!option.isAuthPeer()) { return; } checkTrustedCustom(chain, null); trustManager.checkClientTrusted(chain, authType); } TrustManagerExt(X509ExtendedTrustManager manager, SSLOption option,
SSLCustom custom); @Override void checkClientTrusted(X509Certificate[] chain, String authType); @Override void checkServerTrusted(X509Certificate[] chain, String authType); @Override X509Certificate[] getAcceptedIssuers(); @Override void checkClientTrusted(X509Certificate[] chain, String authType,
Socket socket); @Override void checkClientTrusted(X509Certificate[] chain, String authType,
SSLEngine engine); @Override void checkServerTrusted(X509Certificate[] chain, String authType,
Socket socket); @Override void checkServerTrusted(X509Certificate[] chain, String authType,
SSLEngine engine); } | @Test public void testCheckClientTrusted(@Mocked CertificateUtil certificateUtil) { MyX509Certificate myX509Certificate1 = new MyX509Certificate(); MyX509Certificate myX509Certificate2 = new MyX509Certificate(); MyX509Certificate[] MyX509CertificateArray = new MyX509Certificate[2]; MyX509CertificateArray[0] = myX509Certificate1; MyX509CertificateArray[1] = myX509Certificate2; new Expectations() { { CertificateUtil.findOwner((X509Certificate[]) any); result = any; CertificateUtil.getCN((X509Certificate) any); result = "10.67.147.115"; } }; MyX509ExtendedTrustManager myX509ExtendedTrustManager = new MyX509ExtendedTrustManager(); TrustManagerExt trustManagerExt = new TrustManagerExt(myX509ExtendedTrustManager, option, custom); Socket socket = null; SSLEngine sslengine = null; boolean validAssert = true; try { trustManagerExt.checkClientTrusted(MyX509CertificateArray, "pks", socket); trustManagerExt.checkClientTrusted(MyX509CertificateArray, "pks", sslengine); trustManagerExt.checkServerTrusted(MyX509CertificateArray, "pks", socket); trustManagerExt.checkServerTrusted(MyX509CertificateArray, "pks", sslengine); } catch (Exception e) { validAssert = false; } Assert.assertTrue(validAssert); }
@Test public void testCatchException(@Mocked CertificateUtil certificateUtil) { MyX509Certificate myX509Certificate1 = new MyX509Certificate(); MyX509Certificate myX509Certificate2 = new MyX509Certificate(); MyX509Certificate[] MyX509CertificateArray = new MyX509Certificate[2]; MyX509CertificateArray[0] = myX509Certificate1; MyX509CertificateArray[1] = myX509Certificate2; new Expectations() { { CertificateUtil.findOwner((X509Certificate[]) any); result = any; CertificateUtil.getCN((X509Certificate) any); result = "10.67.147.114"; } }; MyX509ExtendedTrustManager myX509ExtendedTrustManager = new MyX509ExtendedTrustManager(); TrustManagerExt trustManagerExt = new TrustManagerExt(myX509ExtendedTrustManager, option, custom); boolean validAssert = true; try { trustManagerExt.checkClientTrusted(MyX509CertificateArray, "pks"); } catch (CertificateException e) { Assert.assertEquals("CN does not match IP: e=[10.67.147.114],t=null", e.getMessage()); validAssert = false; } Assert.assertFalse(validAssert); } |
SSLSocketFactoryExt extends SSLSocketFactory { @Override public Socket createSocket(Socket s, String host, int port, boolean autoClose) throws IOException { return wrapSocket((SSLSocket) this.sslSocketFactory.createSocket(s, host, port, autoClose)); } SSLSocketFactoryExt(SSLSocketFactory factory, String[] ciphers, String[] protos); @Override Socket createSocket(Socket s, String host, int port, boolean autoClose); @Override String[] getDefaultCipherSuites(); @Override String[] getSupportedCipherSuites(); @Override Socket createSocket(String host, int port); @Override Socket createSocket(InetAddress host, int port); @Override Socket createSocket(String host, int port, InetAddress localHost,
int localPort); @Override Socket createSocket(InetAddress address, int port, InetAddress localAddress,
int localPort); } | @Test public void testCreateSocketException() { boolean validAssert = true; try { instance.createSocket("host", 8080); } catch (Exception e) { validAssert = false; } Assert.assertFalse(validAssert); } |
KeyStoreUtil { public static KeyStore createKeyStore(String storename, String storetype, char[] storevalue) { InputStream is = null; try { KeyStore keystore = KeyStore.getInstance(storetype); is = new FileInputStream(storename); keystore.load(is, storevalue); return keystore; } catch (Exception e) { throw new IllegalArgumentException("Bad key store or value." + e.getMessage()); } finally { if (is != null) { try { is.close(); } catch (IOException e) { ignore(); } } } } private KeyStoreUtil(); static KeyStore createKeyStore(String storename, String storetype,
char[] storevalue); @SuppressWarnings({"rawtypes", "unchecked"}) static CRL[] createCRL(String crlfile); static KeyManager[] createKeyManagers(final KeyStore keystore,
char[] keyvalue); static TrustManager[] createTrustManagers(final KeyStore keystore); } | @Test public void testCreateKeyStoreException() { String storename = ""; String storetype = "testType"; char[] storevalue = "Changeme_123".toCharArray(); try { KeyStoreUtil.createKeyStore(storename, storetype, storevalue); } catch (IllegalArgumentException e) { Assert.assertEquals("Bad key store or value.testType not found", e.getMessage()); } }
@Test public void testCreateKeyStoreException2() { String storename = strFilePath + "/ssl/trust.jks"; String storetype = "PKCS12"; char[] storevalue = "Changeme_123".toCharArray(); try { KeyStoreUtil.createKeyStore(storename, storetype, storevalue); } catch (IllegalArgumentException e) { Assert.assertEquals("Bad key store or value.DerInputStream.getLength(): lengthTag=109, too big.", e.getMessage()); } } |
KeyStoreUtil { @SuppressWarnings({"rawtypes", "unchecked"}) public static CRL[] createCRL(String crlfile) { InputStream is = null; try { CertificateFactory cf = CertificateFactory.getInstance("X.509"); is = new FileInputStream(crlfile); Collection c = cf.generateCRLs(is); CRL[] crls = (CRL[]) c.toArray(new CRL[c.size()]); return crls; } catch (CertificateException e) { throw new IllegalArgumentException("bad cert file."); } catch (FileNotFoundException e) { throw new IllegalArgumentException("crl file not found."); } catch (CRLException e) { throw new IllegalArgumentException("bad crl file."); } finally { if (is != null) { try { is.close(); } catch (IOException e) { ignore(); } } } } private KeyStoreUtil(); static KeyStore createKeyStore(String storename, String storetype,
char[] storevalue); @SuppressWarnings({"rawtypes", "unchecked"}) static CRL[] createCRL(String crlfile); static KeyManager[] createKeyManagers(final KeyStore keystore,
char[] keyvalue); static TrustManager[] createTrustManagers(final KeyStore keystore); } | @Test public void testCreateCRL() { String crlfile = strFilePath + "/ssl/server.p12"; mockGenerateCRLs(); boolean validAssert = true; try { CRL[] crl = KeyStoreUtil.createCRL(crlfile); Assert.assertNull(crl); } catch (Exception e) { validAssert = false; } Assert.assertTrue(validAssert); }
@Test public void testCreateCRLException() { String crlfile = strFilePath + "/ssl/server.p12"; boolean validAssert = true; try { new MockUp<CertificateFactory>() { @Mock public final CertificateFactory getInstance(String type) throws CertificateException { throw new CertificateException(); } }; KeyStoreUtil.createCRL(crlfile); } catch (Exception e) { validAssert = false; } Assert.assertFalse(validAssert); }
@Test public void testExceptionFileNotFound() { String crlfile = strFilePath + "/ssl/server.p12"; boolean validAssert = true; try { new MockUp<CertificateFactory>() { @Mock public final CertificateFactory getInstance( String type) throws CertificateException, FileNotFoundException { throw new FileNotFoundException(); } }; KeyStoreUtil.createCRL(crlfile); } catch (Exception e) { validAssert = false; Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } Assert.assertFalse(validAssert); }
@Test public void testExceptionCRLException() { String crlfile = strFilePath + "/ssl/server.p12"; boolean validAssert = true; try { new MockUp<CertificateFactory>() { @Mock public final CertificateFactory getInstance(String type) throws CertificateException, CRLException { throw new CRLException(); } }; KeyStoreUtil.createCRL(crlfile); } catch (Exception e) { validAssert = false; Assert.assertEquals("java.lang.IllegalArgumentException", e.getClass().getName()); } Assert.assertFalse(validAssert); } |
ProtoParser { public Proto parse(String name) { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); try { if (classLoader == null) { Thread.currentThread().setContextClassLoader(ProtoParser.class.getClassLoader()); } ProtoContext context = loader.load(defaultReader, name); return context.getProto(); } finally { Thread.currentThread().setContextClassLoader(classLoader); } } Proto parseFromContent(String content); Proto parse(String name); } | @Test public void parse() throws IOException { URL url = Thread.currentThread().getContextClassLoader().getResource("protobufRoot.proto"); String content = IOUtils.toString(url, StandardCharsets.UTF_8); ProtoParser parser = new ProtoParser(); Proto protoFromContent = parser.parseFromContent(content); Proto protoFromName = parser.parse("protobufRoot.proto"); Assert.assertNotNull(protoFromContent.getMessage("Root")); Assert.assertNotNull(protoFromContent.getMessage("User")); Assert.assertEquals(MoreObjects.toStringHelper(protoFromContent) .omitNullValues() .add("messages", protoFromContent.getMessages()) .toString(), MoreObjects.toStringHelper(protoFromName) .omitNullValues() .add("messages", protoFromName.getMessages()) .toString()); } |
BeanDescriptorManager { public BeanDescriptor getOrCreateBeanDescriptor(Type type) { return beanDescriptors.computeIfAbsent(type, this::createBeanDescriptor); } BeanDescriptorManager(SerializationConfig serializationConfig); BeanDescriptor getOrCreateBeanDescriptor(Type type); } | @Test public void generic() { Method method = ReflectUtils.findMethod(GenericSchema.class, "genericMethod"); BeanDescriptor beanDescriptor = beanDescriptorManager .getOrCreateBeanDescriptor(method.getGenericParameterTypes()[0]); Assert.assertEquals(String.class, beanDescriptor.getPropertyDescriptors().get("value").getJavaType().getRawClass()); }
@Test public void getOrCreate() { Assert.assertSame(beanDescriptor, beanDescriptorManager.getOrCreateBeanDescriptor(Model.class)); Assert.assertSame(Model.class, beanDescriptor.getJavaType().getRawClass()); } |
LatencyDistributionConfig { public List<LatencyScopeConfig> getScopeConfigs() { return scopeConfigs; } LatencyDistributionConfig(String config); List<LatencyScopeConfig> getScopeConfigs(); } | @Test public void testValidProperty() { String validProperty1 = "0,1,2,10"; String validProperty2 = "0,1, 2 , 10 "; String validProperty3 = "0,1,2,10,"; LatencyDistributionConfig config1 = new LatencyDistributionConfig(validProperty1); LatencyDistributionConfig config2 = new LatencyDistributionConfig(validProperty2); LatencyDistributionConfig config3 = new LatencyDistributionConfig(validProperty3); Assert.assertEquals(4, config1.getScopeConfigs().size()); Assert.assertEquals(4, config2.getScopeConfigs().size()); Assert.assertEquals(4, config3.getScopeConfigs().size()); }
@Test public void testInValidProperty1() { expectedException.expect(IllegalStateException.class); expectedException.expectMessage("invalid latency scope, min=2, max=1."); LatencyDistributionConfig latencyDistributionConfig = new LatencyDistributionConfig("2,1,10"); Assert.assertEquals(0, latencyDistributionConfig.getScopeConfigs().size()); }
@Test public void testInValidProperty2() { expectedException.expect(NumberFormatException.class); expectedException.expectMessage("For input string: \"a\""); LatencyDistributionConfig latencyDistributionConfig = new LatencyDistributionConfig("a,1,10"); Assert.assertEquals(0, latencyDistributionConfig.getScopeConfigs().size()); } |
DefaultTagFinder implements TagFinder { @Override public String getTagKey() { return tagKey; } DefaultTagFinder(String tagKey); DefaultTagFinder(String tagKey, boolean skipOnNull); @Override boolean skipOnNull(); @Override String getTagKey(); @Override Tag find(Iterable<Tag> tags); } | @Test public void getTagKey() { Assert.assertEquals("key", finder.getTagKey()); } |
DefaultTagFinder implements TagFinder { @Override public Tag find(Iterable<Tag> tags) { for (Tag tag : tags) { if (tag.key().equals(tagKey)) { return tag; } } return null; } DefaultTagFinder(String tagKey); DefaultTagFinder(String tagKey, boolean skipOnNull); @Override boolean skipOnNull(); @Override String getTagKey(); @Override Tag find(Iterable<Tag> tags); } | @Test public void readSucc() { Tag tag = new BasicTag("key", "value"); List<Tag> tags = Arrays.asList(new BasicTag("t1", "t1v"), tag); Assert.assertSame(tag, finder.find(tags)); }
@Test public void readFail() { List<Tag> tags = Arrays.asList(new BasicTag("t1", "t1v")); Assert.assertNull(finder.find(tags)); } |
MeasurementGroupConfig { public void addGroup(String idName, Object... tagNameOrFinders) { groups.put(idName, Arrays .asList(tagNameOrFinders) .stream() .map(r -> TagFinder.build(r)) .collect(Collectors.toList())); } MeasurementGroupConfig(); MeasurementGroupConfig(String idName, Object... tagNameOrFinders); void addGroup(String idName, Object... tagNameOrFinders); List<TagFinder> findTagFinders(String idName); } | @Test public void addGroup() { config.addGroup("id1", "tag1.1", "tag1.2"); config.addGroup("id2", "tag2.1", "tag2.2"); Assert.assertThat(groups.keySet(), Matchers.contains("id2", "id1")); Assert.assertThat(groups.get("id1").stream().map(e -> { return e.getTagKey(); }).toArray(), Matchers.arrayContaining("tag1.1", "tag1.2")); Assert.assertThat(groups.get("id2").stream().map(e -> { return e.getTagKey(); }).toArray(), Matchers.arrayContaining("tag2.1", "tag2.2")); } |
MeasurementTree extends MeasurementNode { public void from(Iterator<Meter> meters, MeasurementGroupConfig groupConfig) { meters.forEachRemaining(meter -> { Iterable<Measurement> measurements = meter.measure(); from(measurements, groupConfig); }); } MeasurementTree(); void from(Iterator<Meter> meters, MeasurementGroupConfig groupConfig); void from(Iterable<Measurement> measurements, MeasurementGroupConfig groupConfig); } | @Test public void from() { timer.record(10, TimeUnit.NANOSECONDS); timer.record(2, TimeUnit.NANOSECONDS); MeasurementGroupConfig config = new MeasurementGroupConfig("id", "g1", "g2", Statistic.count.key()); tree.from(registry.iterator(), config); Assert.assertEquals(2, tree.getChildren().size()); MeasurementNode node = tree.findChild("id", "g1v", "g2v"); Assert.assertEquals(2d, node.findChild(Statistic.count.value()).getMeasurements().get(0).value(), 0); Assert.assertEquals(12d, node.findChild(Statistic.totalTime.value()).getMeasurements().get(0).value(), 0); Assert.assertEquals(0d, tree.findChild("id_notCare").summary(), 0); }
@Test public void from_withSkipOnNull() { try { MeasurementGroupConfig config = new MeasurementGroupConfig("id", new DefaultTagFinder("notExist", true)); tree.from(registry.iterator(), config); } catch (Exception e) { Assert.fail("should not throw exception"); } }
@Test public void from_failed() { expectedException.expect(IllegalStateException.class); expectedException.expectMessage(Matchers .is("tag key \"notExist\" not exist in Measurement(id:g1=g1v:g2=g2v:statistic=count:t3=t3v:t4=t4v,0,0.0)")); MeasurementGroupConfig config = new MeasurementGroupConfig("id", "notExist"); tree.from(registry.iterator(), config); } |
MeasurementNode { public String getName() { return name; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); } | @Test public void getName() { Assert.assertEquals("name", node.getName()); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @VisibleForTesting @SuppressWarnings("unchecked") protected <T> Handler<RestResponse> syncHandler(CountDownLatch countDownLatch, Class<T> cls, Holder<T> holder) { return restResponse -> { RequestContext requestContext = restResponse.getRequestContext(); HttpClientResponse response = restResponse.getResponse(); if (response == null) { if (requestContext.getRetryTimes() <= ipPortManager.getMaxRetryTimes()) { retry(requestContext, syncHandler(countDownLatch, cls, holder)); } else { countDownLatch.countDown(); } return; } holder.setStatusCode(response.statusCode()); response.exceptionHandler(e -> { LOGGER.error("error in processing response.", e); countDownLatch.countDown(); }); response.bodyHandler( bodyBuffer -> { if (cls.getName().equals(HttpClientResponse.class.getName())) { holder.value = (T) response; countDownLatch.countDown(); return; } if (cls.equals(String.class)) { holder.setValue((T) bodyBuffer.toString()); countDownLatch.countDown(); return; } if (HttpStatusClass.CLIENT_ERROR.equals(HttpStatusClass.valueOf(response.statusCode()))) { try { Map<String, String> bufferMap = JsonUtils.readValue(bodyBuffer.getBytes(), Map.class); if (bufferMap.containsKey(ERROR_CODE)) { String errorCode = bufferMap.get(ERROR_CODE); if (errorCode.equals(ERR_SERVICE_NOT_EXISTS) || errorCode.equals(ERR_SCHEMA_NOT_EXISTS)) { countDownLatch.countDown(); return; } } } catch (IOException e) { LOGGER.warn("read value failed from buffer {}", bodyBuffer.toString()); } } if (!HttpStatusClass.SUCCESS.equals(HttpStatusClass.valueOf(response.statusCode()))) { LOGGER.warn("get response for {} failed, {}:{}, {}", cls.getName(), response.statusCode(), response.statusMessage(), bodyBuffer.toString()); countDownLatch.countDown(); return; } try { holder.value = JsonUtils.readValue(bodyBuffer.getBytes(), cls); } catch (Exception e) { holder.setStatusCode(0).setThrowable(e); LOGGER.warn("read value failed and response message is {}", bodyBuffer.toString()); } countDownLatch.countDown(); }); }; } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void syncHandler_failed(@Mocked RequestContext requestContext, @Mocked HttpClientResponse response) { CountDownLatch countDownLatch = new CountDownLatch(1); Class<GetExistenceResponse> cls = GetExistenceResponse.class; Holder<GetExistenceResponse> holder = new Holder<>(); Handler<RestResponse> handler = oClient.syncHandler(countDownLatch, cls, holder); Holder<Handler<Buffer>> bodyHandlerHolder = new Holder<>(); new MockUp<HttpClientResponse>(response) { @Mock HttpClientResponse bodyHandler(Handler<Buffer> bodyHandler) { bodyHandlerHolder.value = bodyHandler; return null; } }; new Expectations() { { response.statusCode(); result = 400; response.statusMessage(); result = Status.BAD_REQUEST.getReasonPhrase(); } }; RestResponse event = new RestResponse(requestContext, response); handler.handle(event); Buffer bodyBuffer = Buffer.buffer("{}"); bodyHandlerHolder.value.handle(bodyBuffer); Assert.assertNull(holder.value); } |
MeasurementNode { public Map<String, MeasurementNode> getChildren() { return children; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); } | @Test public void getChildren() { Map<String, MeasurementNode> children = new HashMap<>(); node = new MeasurementNode("name", children); Assert.assertSame(children, node.getChildren()); } |
MeasurementNode { public MeasurementNode findChild(String childName) { if (children == null) { return null; } return children.get(childName); } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); } | @Test public void findChild_noChildren() { Assert.assertNull(node.findChild("child")); } |
MeasurementNode { public MeasurementNode addChild(String childName, Measurement measurement) { if (children == null) { children = new LinkedHashMap<>(); } MeasurementNode node = children.computeIfAbsent(childName, name -> new MeasurementNode(name, null)); node.addMeasurement(measurement); return node; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); } | @Test public void addChild(@Mocked Measurement measurement) { MeasurementNode c1 = node.addChild("c1", measurement); MeasurementNode c2 = node.addChild("c2", measurement); Assert.assertSame(c1, node.findChild("c1")); Assert.assertSame(c2, node.findChild("c2")); } |
MeasurementNode { public List<Measurement> getMeasurements() { return measurements; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); } | @Test public void getMeasurements(@Mocked Measurement measurement) { node.addMeasurement(measurement); Assert.assertThat(node.getMeasurements(), Matchers.contains(measurement)); } |
MeasurementNode { public double summary() { double result = 0; for (Measurement measurement : measurements) { result += measurement.value(); } return result; } MeasurementNode(String name, Map<String, MeasurementNode> children); String getName(); Map<String, MeasurementNode> getChildren(); MeasurementNode findChild(String childName); MeasurementNode findChild(String... childNames); MeasurementNode addChild(String childName, Measurement measurement); List<Measurement> getMeasurements(); void addMeasurement(Measurement measurement); double summary(); } | @Test public void summary(@Mocked Measurement measurement) { new Expectations() { { measurement.value(); result = 10; } }; node.addMeasurement(measurement); node.addMeasurement(measurement); Assert.assertEquals(20, node.summary(), 0); } |
MetricsBootstrap { protected void loadMetricsInitializers() { SPIServiceUtils.getSortedService(MetricsInitializer.class) .forEach(initializer -> initializer.init(globalRegistry, eventBus, config)); } void start(GlobalRegistry globalRegistry, EventBus eventBus); void shutdown(); synchronized void pollMeters(); } | @Test public void loadMetricsInitializers() { List<MetricsInitializer> initList = new ArrayList<>(); MetricsInitializer metricsInitializer = new MetricsInitializer() { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { initList.add(this); } }; new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(MetricsInitializer.class); result = Arrays.asList(metricsInitializer, metricsInitializer); } }; bootstrap.start(globalRegistry, eventBus); bootstrap.shutdown(); Assert.assertThat(initList, Matchers.contains(metricsInitializer, metricsInitializer)); } |
MetricsBootstrap { public synchronized void pollMeters() { try { long secondInterval = TimeUnit.MILLISECONDS.toSeconds(config.getMsPollInterval()); PolledEvent polledEvent = globalRegistry.poll(secondInterval); eventBus.post(polledEvent); } catch (Throwable e) { LOGGER.error("poll meters error. ", e); } } void start(GlobalRegistry globalRegistry, EventBus eventBus); void shutdown(); synchronized void pollMeters(); } | @Test public void pollMeters(@Mocked Registry registry, @Mocked Meter meter, @Mocked Measurement measurement, @Mocked ScheduledExecutorService executor) { List<Meter> meters = Arrays.asList(meter); globalRegistry.add(registry); new Expectations(Executors.class) { { Executors.newScheduledThreadPool(1, (ThreadFactory) any); result = executor; registry.iterator(); result = meters.iterator(); meter.measure(); result = Arrays.asList(measurement); } }; bootstrap.start(globalRegistry, eventBus); PolledEvent result = new PolledEvent(null, null); eventBus.register(new Object() { @Subscribe public void onEvent(PolledEvent event) { result.setMeters(event.getMeters()); result.setMeasurements(event.getMeasurements()); } }); bootstrap.pollMeters(); bootstrap.shutdown(); Assert.assertEquals(meters, result.getMeters()); Assert.assertThat(result.getMeasurements(), Matchers.contains(measurement)); } |
MetricsBootstrap { public void shutdown() { if (executorService != null) { executorService.shutdown(); } List<MetricsInitializer> initializers = new ArrayList<>(SPIServiceUtils.getSortedService(MetricsInitializer.class)); Collections.reverse(initializers); initializers.forEach(initializer -> initializer.destroy()); } void start(GlobalRegistry globalRegistry, EventBus eventBus); void shutdown(); synchronized void pollMeters(); } | @Test public void shutdown(@Mocked ScheduledExecutorService scheduledExecutorService) { List<MetricsInitializer> destroyList = new ArrayList<>(); MetricsInitializer initializer1 = new MetricsInitializer() { @Override public int getOrder() { return 1; } @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { } @Override public void destroy() { destroyList.add(this); } }; MetricsInitializer initializer2 = new MetricsInitializer() { @Override public int getOrder() { return 2; } @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { } @Override public void destroy() { destroyList.add(this); } }; new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(MetricsInitializer.class); result = Arrays.asList(initializer1, initializer2); } }; Deencapsulation.setField(bootstrap, "executorService", scheduledExecutorService); bootstrap.shutdown(); Assert.assertThat(destroyList, Matchers.contains(initializer2, initializer1)); }
@Test public void shutdown_notStart() { Assert.assertNull(Deencapsulation.getField(bootstrap, "executorService")); bootstrap.shutdown(); } |
PlaceholderResolver { public List<String> replace(String str, Map<String, Object> parameters) { List<Row> finalRows = replaceToRows(str, parameters); List<String> replaced = new ArrayList<>(); for (Row row : finalRows) { resolve(row, replaced); } for (int idx = 0; idx < replaced.size(); idx++) { String row = replaced.get(idx); replaced.set(idx, row.replace("\\$", "$")); } return replaced; } String replaceFirst(String str); String replaceFirst(String str, Map<String, Object> parameters); List<String> replace(String str, Map<String, Object> parameters); } | @Test public void unknown() { Assert.assertThat(resolver.replace("prefix${xxx}suffix", parameters), Matchers.contains("prefix${xxx}suffix")); }
@Test public void empty() { Assert.assertThat(resolver.replace("prefix${}suffix", parameters), Matchers.contains("prefix${}suffix")); }
@Test public void notComplete() { Assert.assertThat(resolver.replace("prefix${suffix", parameters), Matchers.contains("prefix${suffix")); }
@Test public void normal() { Assert.assertThat(resolver.replace("prefix.${key}.suffix", parameters), Matchers.contains("prefix.value.suffix")); }
@Test public void disable() { Assert.assertThat(resolver.replace("prefix.\\${key}.suffix", parameters), Matchers.contains("prefix.${key}.suffix")); }
@Test public void varOfVar() { Assert.assertThat(resolver.replace("prefix.${varOfVar}.suffix", parameters), Matchers.contains("prefix.value.suffix")); }
@Test public void list() { Assert.assertThat(resolver.replace("prefix.${low-list}.suffix", parameters), Matchers.contains("prefix.low-1.suffix", "prefix.low-2.suffix")); }
@Test public void multi_list() { Assert.assertThat(resolver.replace("prefix.${low-list}.${middle-list}.${high-list}.suffix", parameters), Matchers.contains( "prefix.low-1.middle-1.high-1.suffix", "prefix.low-1.middle-1.high-2.suffix", "prefix.low-1.middle-2.high-1.suffix", "prefix.low-1.middle-2.high-2.suffix", "prefix.low-2.middle-1.high-1.suffix", "prefix.low-2.middle-1.high-2.suffix", "prefix.low-2.middle-2.high-1.suffix", "prefix.low-2.middle-2.high-2.suffix")); }
@Test public void nested() { Assert.assertThat(resolver.replace("prefix.${${priority}-list}.suffix", parameters), Matchers.contains("prefix.low-1.suffix", "prefix.low-2.suffix")); }
@Test public void mixed() { Assert.assertThat(resolver.replace("prefix.${${priority}-list}.${key}.${high-list}.suffix ${xxx}", parameters), Matchers.contains( "prefix.low-1.value.high-1.suffix ${xxx}", "prefix.low-2.value.high-1.suffix ${xxx}", "prefix.low-1.value.high-2.suffix ${xxx}", "prefix.low-2.value.high-2.suffix ${xxx}")); } |
ServiceRegistryClientImpl implements ServiceRegistryClient { @Override public boolean isSchemaExist(String microserviceId, String schemaId) { Holder<GetExistenceResponse> holder = new Holder<>(); IpPort ipPort = ipPortManager.getAvailableAddress(); CountDownLatch countDownLatch = new CountDownLatch(1); restClientUtil.get(ipPort, Const.REGISTRY_API.MICROSERVICE_EXISTENCE, new RequestParam().addQueryParam("type", "schema") .addQueryParam("serviceId", microserviceId) .addQueryParam("schemaId", schemaId), syncHandler(countDownLatch, GetExistenceResponse.class, holder)); try { countDownLatch.await(); } catch (Exception e) { LOGGER.error("query schema exist {}/{} fail", microserviceId, schemaId, e); } return holder.value != null && schemaId.equals(holder.value.getSchemaId()); } ServiceRegistryClientImpl(ServiceRegistryConfig serviceRegistryConfig); @Override void init(); @Override List<Microservice> getAllMicroservices(); @Override String getMicroserviceId(String appId, String microserviceName, String versionRule, String environment); @Override boolean isSchemaExist(String microserviceId, String schemaId); @Override boolean registerSchema(String microserviceId, String schemaId, String schemaContent); @Override String getSchema(String microserviceId, String schemaId); @Override String getAggregatedSchema(String microserviceId, String schemaId); @Override Holder<List<GetSchemaResponse>> getSchemas(String microserviceId); @Override String registerMicroservice(Microservice microservice); @Override Microservice getMicroservice(String microserviceId); @Override Microservice getAggregatedMicroservice(String microserviceId); @Override String registerMicroserviceInstance(MicroserviceInstance instance); @Override List<MicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); @Override boolean unregisterMicroserviceInstance(String microserviceId, String microserviceInstanceId); @Override HeartbeatResponse heartbeat(String microserviceId, String microserviceInstanceId); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback); void watch(String selfMicroserviceId, AsyncResultCallback<MicroserviceInstanceChangedEvent> callback,
AsyncResultCallback<Void> onOpen, AsyncResultCallback<Void> onClose); @Override List<MicroserviceInstance> findServiceInstance(String consumerId, String appId, String serviceName,
String versionRule); @Override MicroserviceInstances findServiceInstances(String consumerId, String appId, String serviceName,
String versionRule, String revision); @Override boolean updateMicroserviceProperties(String microserviceId, Map<String, String> serviceProperties); @Override boolean updateInstanceProperties(String microserviceId, String microserviceInstanceId,
Map<String, String> instanceProperties); @Override MicroserviceInstance findServiceInstance(String serviceId, String instanceId); @Override ServiceCenterInfo getServiceCenterInfo(); @Override boolean updateMicroserviceInstanceStatus(String microserviceId, String instanceId,
MicroserviceInstanceStatus status); @Subscribe void onMicroserviceHeartbeatTask(MicroserviceInstanceHeartbeatTask event); } | @Test public void isSchemaExist() { String microserviceId = "msId"; String schemaId = "schemaId"; new MockUp<RestClientUtil>() { @Mock void httpDo(RequestContext requestContext, Handler<RestResponse> responseHandler) { Holder<GetExistenceResponse> holder = Deencapsulation.getField(responseHandler, "arg$4"); holder.value = new GetExistenceResponse(); } }; Assert.assertFalse(oClient.isSchemaExist(microserviceId, schemaId)); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.