method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
MicroservicePaths { public void addResource(RestOperationMeta swaggerRestOperation) { if (swaggerRestOperation.isAbsoluteStaticPath()) { addStaticPathResource(swaggerRestOperation); return; } dynamicPathOperationsList.add(swaggerRestOperation); } void sortPath(); void addResource(RestOperationMeta swaggerRestOperation); Map<String, OperationGroup> getStaticPathOperationMap(); List<RestOperationMeta> getDynamicPathOperationList(); void printPaths(); }### Answer:
@Test public void testAddResourceStaticDuplicatedHttpMethod(@Mocked RestOperationMeta staticResPost) { new Expectations() { { staticResPost.getHttpMethod(); result = "POST"; staticResPost.getAbsolutePath(); result = "/static/"; staticResPost.isAbsoluteStaticPath(); result = true; } }; expectedException.expect(ServiceCombException.class); expectedException.expectMessage("operation with url /static/, method POST is duplicated."); paths.addResource(staticResPost); }
|
### Question:
MicroservicePaths { public List<RestOperationMeta> getDynamicPathOperationList() { return dynamicPathOperationsList; } void sortPath(); void addResource(RestOperationMeta swaggerRestOperation); Map<String, OperationGroup> getStaticPathOperationMap(); List<RestOperationMeta> getDynamicPathOperationList(); void printPaths(); }### Answer:
@Test public void dynamicPath() { Assert.assertEquals("dynamicExId", paths.getDynamicPathOperationList().get(0).getOperationMeta().getOperationId()); Assert.assertEquals("dynamicId", paths.getDynamicPathOperationList().get(1).getOperationMeta().getOperationId()); }
|
### Question:
MicroservicePaths { public void printPaths() { for (Entry<String, OperationGroup> entry : staticPathOperations.entrySet()) { OperationGroup operationGroup = entry.getValue(); printPath(operationGroup.values()); } printPath(getDynamicPathOperationList()); } void sortPath(); void addResource(RestOperationMeta swaggerRestOperation); Map<String, OperationGroup> getStaticPathOperationMap(); List<RestOperationMeta> getDynamicPathOperationList(); void printPaths(); }### Answer:
@Test public void testPrintPaths() { try (LogCollector collector = new LogCollector()) { paths.printPaths(); StringBuilder sb = new StringBuilder(); collector.getEvents().stream() .forEach(e -> sb.append(e.getMessage()).append("\n")); Assert.assertEquals( "Swagger mapped \"{[/static/], method=[POST], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.postStatic()\n" + "Swagger mapped \"{[/static/], method=[GET], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.getStatic()\n" + "Swagger mapped \"{[/staticEx/], method=[GET], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.getStaticEx()\n" + "Swagger mapped \"{[/dynamicEx/{id}/], method=[GET], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.dynamicExId(java.lang.String)\n" + "Swagger mapped \"{[/dynamic/{id}/], method=[GET], produces=[application/json]}\" onto public void org.apache.servicecomb.common.rest.locator.TestPathSchema.dynamicId(java.lang.String)\n", sb.toString()); } }
|
### Question:
RestOperationMeta { public ProduceProcessor ensureFindProduceProcessor(HttpServletRequestEx requestEx) { String acceptType = requestEx.getHeader(HttpHeaders.ACCEPT); return ensureFindProduceProcessor(acceptType); } void init(OperationMeta operationMeta); boolean isDownloadFile(); boolean isFormData(); void setOperationMeta(OperationMeta operationMeta); String getAbsolutePath(); void setAbsolutePath(String absolutePath); PathRegExp getAbsolutePathRegExp(); boolean isAbsoluteStaticPath(); RestParam getParamByName(String name); RestParam getParamByIndex(int index); OperationMeta getOperationMeta(); URLPathBuilder getPathBuilder(); List<RestParam> getParamList(); ProduceProcessor findProduceProcessor(String type); ProduceProcessor ensureFindProduceProcessor(HttpServletRequestEx requestEx); ProduceProcessor ensureFindProduceProcessor(String acceptType); String getHttpMethod(); List<String> getFileKeys(); List<String> getProduces(); }### Answer:
@Test public void testCreateProduceProcessorsTextAndWildcard() { findOperation("textPlain"); Assert.assertSame(ProduceProcessorManager.INSTANCE.findDefaultPlainProcessor(), operationMeta.ensureFindProduceProcessor(MediaType.WILDCARD)); Assert.assertSame(ProduceProcessorManager.INSTANCE.findDefaultPlainProcessor(), operationMeta.ensureFindProduceProcessor(MediaType.TEXT_PLAIN)); Assert.assertNull(operationMeta.ensureFindProduceProcessor(MediaType.APPLICATION_JSON)); Assert.assertSame(ProduceProcessorManager.INSTANCE.findDefaultPlainProcessor(), operationMeta.ensureFindProduceProcessor( MediaType.APPLICATION_JSON + "," + MediaType.APPLICATION_XML + "," + MediaType.WILDCARD)); }
@Test public void testCreateProduceProcessorsTextAndWildcardWithView() { findOperation("textPlainWithView"); Assert.assertSame(ProduceProcessorManager.INSTANCE.findPlainProcessorByViewClass(Object.class), operationMeta.ensureFindProduceProcessor(MediaType.WILDCARD)); Assert.assertSame(ProduceProcessorManager.INSTANCE.findPlainProcessorByViewClass(Object.class), operationMeta.ensureFindProduceProcessor(MediaType.TEXT_PLAIN)); Assert.assertNull(operationMeta.ensureFindProduceProcessor(MediaType.APPLICATION_JSON)); Assert.assertSame(ProduceProcessorManager.INSTANCE.findPlainProcessorByViewClass(Object.class), operationMeta.ensureFindProduceProcessor( MediaType.APPLICATION_JSON + "," + MediaType.APPLICATION_XML + "," + MediaType.WILDCARD)); }
@Test public void testCreateProduceProcessorsWithSemicolon() { findOperation("textCharJsonChar"); Assert.assertSame(ProduceProcessorManager.INSTANCE.findDefaultPlainProcessor(), operationMeta.ensureFindProduceProcessor(MediaType.TEXT_PLAIN)); Assert.assertSame(ProduceProcessorManager.INSTANCE.findDefaultJsonProcessor(), operationMeta.ensureFindProduceProcessor(MediaType.APPLICATION_JSON)); }
@Test public void testCreateProduceProcessorsWithSemicolonWithView() { findOperation("textCharJsonCharWithView"); Assert.assertSame(ProduceProcessorManager.INSTANCE.findPlainProcessorByViewClass(Object.class), operationMeta.ensureFindProduceProcessor(MediaType.TEXT_PLAIN)); Assert.assertSame(ProduceProcessorManager.INSTANCE.findJsonProcessorByViewClass(Object.class), operationMeta.ensureFindProduceProcessor(MediaType.APPLICATION_JSON)); }
@Test public void testEnsureFindProduceProcessorAcceptNotFound() { findOperation("textCharJsonChar"); Assert.assertNull(operationMeta.ensureFindProduceProcessor("notSupport")); }
@Test public void testEnsureFindProduceProcessorAcceptNotFoundWithView() { findOperation("textCharJsonCharWithView"); Assert.assertNull(operationMeta.ensureFindProduceProcessor("notSupport")); }
|
### Question:
EnvAdapterManager extends RegisterManager<String, EnvAdapter> { public void processInstanceWithAdapters(MicroserviceInstance instance) { getObjMap().forEach((name, adapter) -> { LOGGER.info("Start process instance with adapter {}", name); adapter.beforeRegisterInstance(instance); }); } EnvAdapterManager(); void processMicroserviceWithAdapters(Microservice microservice); void processSchemaWithAdapters(String schemaId, String content); void processInstanceWithAdapters(MicroserviceInstance instance); static final EnvAdapterManager INSTANCE; }### Answer:
@Test public void testProcessInstance() { MicroserviceInstance instance = new MicroserviceInstance(); manager.processInstanceWithAdapters(instance); assertEquals("order=0", instance.getProperties().get("cas_env_one")); assertEquals("order=0", instance.getProperties().get("cas_env_two")); assertNull(instance.getProperties().get("default-env-adapter")); }
|
### Question:
RestOperationMeta { public String getAbsolutePath() { return this.absolutePath; } void init(OperationMeta operationMeta); boolean isDownloadFile(); boolean isFormData(); void setOperationMeta(OperationMeta operationMeta); String getAbsolutePath(); void setAbsolutePath(String absolutePath); PathRegExp getAbsolutePathRegExp(); boolean isAbsoluteStaticPath(); RestParam getParamByName(String name); RestParam getParamByIndex(int index); OperationMeta getOperationMeta(); URLPathBuilder getPathBuilder(); List<RestParam> getParamList(); ProduceProcessor findProduceProcessor(String type); ProduceProcessor ensureFindProduceProcessor(HttpServletRequestEx requestEx); ProduceProcessor ensureFindProduceProcessor(String acceptType); String getHttpMethod(); List<String> getFileKeys(); List<String> getProduces(); }### Answer:
@Test public void generatesAbsolutePathWithRootBasePath() { findOperation("textCharJsonChar"); assertThat(operationMeta.getAbsolutePath(), is("/textCharJsonChar/")); }
|
### Question:
RestOperationMeta { public boolean isFormData() { return formData; } void init(OperationMeta operationMeta); boolean isDownloadFile(); boolean isFormData(); void setOperationMeta(OperationMeta operationMeta); String getAbsolutePath(); void setAbsolutePath(String absolutePath); PathRegExp getAbsolutePathRegExp(); boolean isAbsoluteStaticPath(); RestParam getParamByName(String name); RestParam getParamByIndex(int index); OperationMeta getOperationMeta(); URLPathBuilder getPathBuilder(); List<RestParam> getParamList(); ProduceProcessor findProduceProcessor(String type); ProduceProcessor ensureFindProduceProcessor(HttpServletRequestEx requestEx); ProduceProcessor ensureFindProduceProcessor(String acceptType); String getHttpMethod(); List<String> getFileKeys(); List<String> getProduces(); }### Answer:
@Test public void testFormDataFlagTrue() { findOperation("form"); assertThat(operationMeta.isFormData(), is(true)); }
@Test public void testFormDataFlagFalse() { findOperation("json"); assertThat(operationMeta.isFormData(), is(false)); }
|
### Question:
PathVarParamWriter extends AbstractUrlParamWriter { @Override public void write(URLPathStringBuilder builder, Map<String, Object> args) throws Exception { if (getParamValue(args) == null) { throw new IllegalArgumentException("path parameter can not be null."); } String encodedPathParam = encodeNotNullValue(getParamValue(args)); builder.appendPath(encodedPathParam); } PathVarParamWriter(RestParam param); @Override void write(URLPathStringBuilder builder, Map<String, Object> args); }### Answer:
@Test public void writePlainPath() throws Exception { PathVarParamWriter pathVarParamWriter = createPathVarParamWriter(); URLPathStringBuilder pathBuilder = new URLPathStringBuilder(); Map<String, Object> parameters = new HashMap<>(); parameters.put("test", "abc"); pathVarParamWriter.write(pathBuilder, parameters); Assert.assertEquals("abc", pathBuilder.build()); }
@Test public void writePathWithSpace() throws Exception { PathVarParamWriter pathVarParamWriter = createPathVarParamWriter(); URLPathStringBuilder pathBuilder = new URLPathStringBuilder(); Map<String, Object> parameters = new HashMap<>(); parameters.put("test", "a 20bc"); pathVarParamWriter.write(pathBuilder, parameters); Assert.assertEquals("a%2020bc", pathBuilder.build()); }
@Test public void writePathWithPercentage() throws Exception { PathVarParamWriter pathVarParamWriter = createPathVarParamWriter(); URLPathStringBuilder pathBuilder = new URLPathStringBuilder(); pathBuilder.appendPath("/api/"); Map<String, Object> parameters = new HashMap<>(); parameters.put("test", "a%%bc"); pathVarParamWriter.write(pathBuilder, parameters); Assert.assertEquals("/api/a%25%25bc", pathBuilder.build()); }
@Test public void writePathParamWithSlash() throws Exception { PathVarParamWriter pathVarParamWriter = createPathVarParamWriter(); URLPathStringBuilder pathBuilder = new URLPathStringBuilder(); pathBuilder.appendPath("/api/"); Map<String, Object> parameters = new HashMap<>(); parameters.put("test", "a/bc"); pathVarParamWriter.write(pathBuilder, parameters); Assert.assertEquals("/api/a%2Fbc", pathBuilder.build()); }
@Test public void writeIntegerParam() throws Exception { PathVarParamWriter pathVarParamWriter = createPathVarParamWriter(); URLPathStringBuilder pathBuilder = new URLPathStringBuilder(); Map<String, Object> parameters = new HashMap<>(); parameters.put("test", 12); pathVarParamWriter.write(pathBuilder, parameters); Assert.assertEquals("12", pathBuilder.build()); }
|
### Question:
ZeroConfigClient { public boolean register() { String serviceInstanceId = doRegister( ClientUtil.convertToRegisterDataModel(selfMicroserviceInstance, selfMicroservice)); return StringUtils.isNotEmpty(serviceInstanceId); } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked(
ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName,
String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice(
Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance(
MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer:
@Test public void test_register_withCorrectData_RegisterShouldSucceed() { boolean returnedResult = target.register(); Assert.assertTrue(returnedResult); }
@Test public void test_register_MulticastThrowException_RegisterShouldFail() throws IOException { doThrow(IOException.class).when(multicastSocket).send(anyObject()); boolean returnedResult = target.register(); Assert.assertFalse(returnedResult); }
|
### Question:
QueryVarParamWriter extends AbstractUrlParamWriter { private void writeArray(URLPathStringBuilder builder, Object value) throws Exception { if (shouldJoinParams()) { writeJoinedParams(builder, Arrays.asList(((Object[]) value))); return; } for (Object item : (Object[]) value) { writeItem(builder, item); } } QueryVarParamWriter(RestParam param); @Override void write(URLPathStringBuilder builder, Map<String, Object> args); }### Answer:
@Test public void writeArray() throws Exception { URLPathStringBuilder stringBuilder = new URLPathStringBuilder(); Map<String, Object> parameters = new HashMap<>(); parameters.put("q", new String[] {"ab", "cd", "ef"}); queryVarParamWriterCsv.write(stringBuilder, parameters); Assert.assertEquals("?q=ab%2Ccd%2Cef", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterMulti.write(stringBuilder, parameters); Assert.assertEquals("?q=ab&q=cd&q=ef", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterDefault.write(stringBuilder, parameters); Assert.assertEquals("?q=ab&q=cd&q=ef", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); parameters.put("q", new String[] {"a b", " ", "", "ef"}); queryVarParamWriterCsv.write(stringBuilder, parameters); Assert.assertEquals("?q=a+b%2C+%2C%2Cef", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterMulti.write(stringBuilder, parameters); Assert.assertEquals("?q=a+b&q=+&q=&q=ef", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterDefault.write(stringBuilder, parameters); Assert.assertEquals("?q=a+b&q=+&q=&q=ef", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); parameters.put("q", new String[] {""}); queryVarParamWriterCsv.write(stringBuilder, parameters); Assert.assertEquals("?q=", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterMulti.write(stringBuilder, parameters); Assert.assertEquals("?q=", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterDefault.write(stringBuilder, parameters); Assert.assertEquals("?q=", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); parameters.put("q", new String[] {}); queryVarParamWriterCsv.write(stringBuilder, parameters); Assert.assertEquals("", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterMulti.write(stringBuilder, parameters); Assert.assertEquals("", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterDefault.write(stringBuilder, parameters); Assert.assertEquals("", stringBuilder.build()); parameters.put("q", new String[] {null}); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterCsv.write(stringBuilder, parameters); Assert.assertEquals("", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterMulti.write(stringBuilder, parameters); Assert.assertEquals("", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterDefault.write(stringBuilder, parameters); Assert.assertEquals("", stringBuilder.build()); parameters.put("q", new String[] {null, "ab", null, "cd", null, null, "", null, "ef", null}); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterCsv.write(stringBuilder, parameters); Assert.assertEquals("?q=ab%2Ccd%2C%2Cef", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterMulti.write(stringBuilder, parameters); Assert.assertEquals("?q=ab&q=cd&q=&q=ef", stringBuilder.build()); stringBuilder = new URLPathStringBuilder(); queryVarParamWriterDefault.write(stringBuilder, parameters); Assert.assertEquals("?q=ab&q=cd&q=&q=ef", stringBuilder.build()); }
|
### Question:
URLPathBuilder { public String createRequestPath(Map<String, Object> args) throws Exception { URLPathStringBuilder builder = new URLPathStringBuilder(); genPathString(builder, args); genQueryString(builder, args); return builder.build(); } URLPathBuilder(String rawPath, Map<String, RestParam> paramMap); String createRequestPath(Map<String, Object> args); String createPathString(Map<String, Object> args); }### Answer:
@Test public void testMultiQuery() throws Exception { Map<String, RestParam> paramMap = new LinkedHashMap<>(); addParam("strArr", String[].class, QueryParameter::new, paramMap); addParam("intArr", int[].class, QueryParameter::new, paramMap); URLPathBuilder urlPathBuilder = new URLPathBuilder("/path", paramMap); Map<String, Object> parameters = new HashMap<>(); parameters.put("strArr", new Object[] {"a", "b", "c"}); parameters.put("intArr", new Object[] {1, 2, 3}); Assert.assertEquals("/path?strArr=a&strArr=b&strArr=c&intArr=1&intArr=2&intArr=3", urlPathBuilder.createRequestPath(parameters)); parameters.put("strArr", new Object[] {}); parameters.put("intArr", new Object[] {1, 2, 3}); Assert.assertEquals("/path?intArr=1&intArr=2&intArr=3", urlPathBuilder.createRequestPath(parameters)); parameters.put("strArr", new Object[] {"a", "b", "c"}); parameters.put("intArr", new Object[] {}); Assert.assertEquals("/path?strArr=a&strArr=b&strArr=c", urlPathBuilder.createRequestPath(parameters)); parameters.put("strArr", new Object[] {}); parameters.put("intArr", new Object[] {}); Assert.assertEquals("/path", urlPathBuilder.createRequestPath(parameters)); }
|
### Question:
RestProducerInvocation extends AbstractRestInvocation { public void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx, List<HttpServerFilter> httpServerFilters) { this.transport = transport; this.requestEx = requestEx; this.responseEx = responseEx; this.httpServerFilters = httpServerFilters; requestEx.setAttribute(RestConst.REST_REQUEST, requestEx); try { findRestOperation(); } catch (InvocationException e) { sendFailResponse(e); return; } scheduleInvocation(); } void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx,
List<HttpServerFilter> httpServerFilters); }### Answer:
@Test public void invokeSendFail(@Mocked InvocationException expected) { restProducerInvocation = new MockUp<RestProducerInvocation>() { @Mock void sendFailResponse(Throwable throwable) { throwableOfSendFailResponse = throwable; } @Mock void findRestOperation() { throw expected; } @Mock void scheduleInvocation() { throw new IllegalStateException("must not invoke scheduleInvocation"); } }.getMockInstance(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); Assert.assertSame(expected, throwableOfSendFailResponse); }
@Test public void invokeNormal() { restProducerInvocation = new MockUp<RestProducerInvocation>() { @Mock void findRestOperation() { restProducerInvocation.restOperationMeta = restOperationMeta; } @Mock void scheduleInvocation() { scheduleInvocation = true; } }.getMockInstance(); requestEx = new AbstractHttpServletRequest() { }; restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); Assert.assertTrue(scheduleInvocation); Assert.assertSame(requestEx, requestEx.getAttribute(RestConst.REST_REQUEST)); }
|
### Question:
RestProducerInvocation extends AbstractRestInvocation { protected void findRestOperation() { MicroserviceMeta selfMicroserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); findRestOperation(selfMicroserviceMeta); } void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx,
List<HttpServerFilter> httpServerFilters); }### Answer:
@Test public void findRestOperationNameFromRegistry() { Microservice microservice = new Microservice(); microservice.setServiceName("ms"); new Expectations(ServicePathManager.class) { { ServicePathManager.getServicePathManager(microserviceMeta); result = null; } }; restProducerInvocation = new RestProducerInvocation(); initRestProducerInvocation(); expectedException.expect(Exception.class); expectedException.expectMessage("[message=Not Found]"); restProducerInvocation.findRestOperation(); }
@Test public void findRestOperationNormal(@Mocked ServicePathManager servicePathManager, @Mocked OperationLocator locator) { requestEx = new AbstractHttpServletRequest() { @Override public String getRequestURI() { return "/path"; } @Override public String getMethod() { return "GET"; } @Override public String getHeader(String name) { return "ms"; } }; Map<String, String> pathVars = new HashMap<>(); new Expectations(ServicePathManager.class) { { ServicePathManager.getServicePathManager(microserviceMeta); result = servicePathManager; servicePathManager.producerLocateOperation(anyString, anyString); result = locator; locator.getPathVarMap(); result = pathVars; locator.getOperation(); result = restOperationMeta; } }; restProducerInvocation = new RestProducerInvocation(); initRestProducerInvocation(); restProducerInvocation.findRestOperation(); Assert.assertSame(restOperationMeta, restProducerInvocation.restOperationMeta); Assert.assertSame(pathVars, requestEx.getAttribute(RestConst.PATH_PARAMETERS)); }
|
### Question:
VertxRestInvocation extends RestProducerInvocation { @Override protected void createInvocation() { super.createInvocation(); RoutingContext routingContext = ((VertxServerRequestToHttpServletRequest) this.requestEx).getContext(); VertxHttpTransportContext transportContext = new VertxHttpTransportContext(routingContext, requestEx, responseEx, produceProcessor); invocation.setTransportContext(transportContext); routingContext.put(RestConst.REST_INVOCATION_CONTEXT, this.invocation); } }### Answer:
@Test public void testCreateInvocation() { new MockUp<RestProducerInvocation>() { @Mock void createInvocation() { } }; VertxRestInvocation vertxRestInvocation = new VertxRestInvocation(); VertxServerRequestToHttpServletRequest requestEx = Mockito.mock(VertxServerRequestToHttpServletRequest.class); RoutingContext routingContext = Mockito.mock(RoutingContext.class); Invocation invocation = Mockito.mock(Invocation.class); Deencapsulation.setField( vertxRestInvocation, "requestEx", requestEx); Deencapsulation.setField( vertxRestInvocation, "invocation", invocation); Mockito.when(requestEx.getContext()).thenReturn(routingContext); Deencapsulation.invoke(vertxRestInvocation, "createInvocation"); Mockito.verify(routingContext, Mockito.times(1)).put(RestConst.REST_INVOCATION_CONTEXT, invocation); }
|
### Question:
Utils { public static String findActualPath(String path, int pathIndex) { if (pathIndex <= 0) { return path; } int fromIndex = 0; int counter = pathIndex; char[] chars = path.toCharArray(); for (int i = 0; i < chars.length; i++) { if (chars[i] == '/') { if (--counter < 0) { fromIndex = i; break; } } } return fromIndex > 0 ? path.substring(fromIndex) : ""; } private Utils(); static String findActualPath(String path, int pathIndex); }### Answer:
@Test public void testUtisl() { Assert.assertEquals(Utils.findActualPath("/a/b/c", -1), "/a/b/c"); Assert.assertEquals(Utils.findActualPath("/a/b/c", 0), "/a/b/c"); Assert.assertEquals(Utils.findActualPath("/a/b/c", 1), "/b/c"); Assert.assertEquals(Utils.findActualPath("/a/b/c", 2), "/c"); Assert.assertEquals(Utils.findActualPath("/a/b/c", 3), ""); Assert.assertEquals(Utils.findActualPath("/a/b/c", 100), ""); }
|
### Question:
DefaultEdgeDispatcher extends AbstractEdgeDispatcher { protected void onRequest(RoutingContext context) { Map<String, String> pathParams = context.pathParams(); String microserviceName = pathParams.get("param0"); String path = Utils.findActualPath(context.request().path(), prefixSegmentCount); EdgeInvocation edgeInvocation = createEdgeInvocation(); if (withVersion) { String pathVersion = pathParams.get("param1"); edgeInvocation.setVersionRule(versionMapper.getOrCreate(pathVersion).getVersionRule()); } edgeInvocation.init(microserviceName, context, path, httpServerFilters); edgeInvocation.edgeInvoke(); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); }### Answer:
@Test @SuppressWarnings("unchecked") public void testOnRequest(@Mocked Router router, @Mocked Route route , @Mocked RoutingContext context , @Mocked HttpServerRequest requst , @Mocked EdgeInvocation invocation) { DefaultEdgeDispatcher dispatcher = new DefaultEdgeDispatcher(); Map<String, String> pathParams = new HashMap<>(); pathParams.put("param0", "testService"); pathParams.put("param1", "v1"); new Expectations() { { router.routeWithRegex("/api/([^\\\\/]+)/([^\\\\/]+)/(.*)"); result = route; route.handler((Handler<RoutingContext>) any); result = route; route.failureHandler((Handler<RoutingContext>) any); result = route; context.pathParams(); result = pathParams; context.request(); result = requst; requst.path(); result = "/api/testService/v1/hello"; invocation.setVersionRule("1.0.0.0-2.0.0.0"); invocation.init("testService", context, "/testService/v1/hello", Deencapsulation.getField(dispatcher, "httpServerFilters")); invocation.edgeInvoke(); } }; dispatcher.init(router); Assert.assertEquals(dispatcher.enabled(), false); Assert.assertEquals(Utils.findActualPath("/api/test", 1), "/test"); Assert.assertEquals(dispatcher.getOrder(), 20000); dispatcher.onRequest(context); }
|
### Question:
AbstractEdgeDispatcher extends AbstractVertxHttpDispatcher { protected void onFailure(RoutingContext context) { LOGGER.error("edge server failed.", context.failure()); HttpServerResponse response = context.response(); if (response.closed() || response.ended()) { return; } if (context.failure() instanceof InvocationException) { InvocationException exception = (InvocationException) context.failure(); response.setStatusCode(exception.getStatusCode()); response.setStatusMessage(exception.getReasonPhrase()); if (null == exception.getErrorData()) { response.end(); return; } String responseBody; try { responseBody = RestObjectMapperFactory.getRestObjectMapper().writeValueAsString(exception.getErrorData()); response.putHeader("Content-Type", MediaType.APPLICATION_JSON); } catch (JsonProcessingException e) { responseBody = exception.getErrorData().toString(); response.putHeader("Content-Type", MediaType.TEXT_PLAIN); } response.end(responseBody); } else { response.setStatusCode(Status.BAD_GATEWAY.getStatusCode()); response.setStatusMessage(Status.BAD_GATEWAY.getReasonPhrase()); response.end(); } } }### Answer:
@Test public void onFailure(@Mocked RoutingContext context) { Map<String, Object> map = new HashMap<>(); HttpServerResponse response = new MockUp<HttpServerResponse>() { @Mock HttpServerResponse setStatusCode(int statusCode) { map.put("code", statusCode); return null; } @Mock HttpServerResponse setStatusMessage(String statusMessage) { map.put("msg", statusMessage); return null; } }.getMockInstance(); new Expectations() { { context.failure(); returns(new RuntimeExceptionWithoutStackTrace("failed"), null); context.response(); result = response; } }; AbstractEdgeDispatcherForTest dispatcher = new AbstractEdgeDispatcherForTest(); dispatcher.onFailure(context); Assert.assertEquals(502, map.get("code")); Assert.assertEquals("Bad Gateway", map.get("msg")); new Expectations() { { context.failure(); returns(new InvocationException(401, "unauthorized", "unauthorized"), new InvocationException(401, "unauthorized", "unauthorized")); context.response(); result = response; } }; dispatcher = new AbstractEdgeDispatcherForTest(); dispatcher.onFailure(context); Assert.assertEquals(401, map.get("code")); Assert.assertEquals("unauthorized", map.get("msg")); }
|
### Question:
EdgeBootListener implements BootListener { @Override public void onBootEvent(BootEvent event) { if (!EventType.BEFORE_PRODUCER_PROVIDER.equals(event.getEventType())) { return; } TransportClientConfig.setRestTransportClientCls(EdgeRestTransportClient.class); TransportConfig.setRestServerVerticle(EdgeRestServerVerticle.class); String defaultExecutor = DynamicPropertyFactory.getInstance() .getStringProperty(ExecutorManager.KEY_EXECUTORS_DEFAULT, null) .get(); if (defaultExecutor != null) { LOGGER.info("Edge service default executor is {}.", defaultExecutor); return; } Configuration configuration = (Configuration) DynamicPropertyFactory.getBackingConfigurationSource(); configuration.setProperty(ExecutorManager.KEY_EXECUTORS_DEFAULT, ExecutorManager.EXECUTOR_REACTIVE); LOGGER.info("Set ReactiveExecutor to be edge service default executor."); } @Override void onBootEvent(BootEvent event); }### Answer:
@Test public void onBootEvent_ignore() { System.setProperty(ExecutorManager.KEY_EXECUTORS_DEFAULT, ExecutorManager.EXECUTOR_DEFAULT); bootEvent.setEventType(EventType.AFTER_CONSUMER_PROVIDER); listener.onBootEvent(bootEvent); Assert.assertEquals(ExecutorManager.EXECUTOR_DEFAULT, DynamicPropertyFactory.getInstance().getStringProperty(ExecutorManager.KEY_EXECUTORS_DEFAULT, null).get()); }
@Test public void onBootEvent_accept_notChange() { System.setProperty(ExecutorManager.KEY_EXECUTORS_DEFAULT, ExecutorManager.EXECUTOR_DEFAULT); bootEvent.setEventType(EventType.BEFORE_PRODUCER_PROVIDER); listener.onBootEvent(bootEvent); Assert.assertEquals(ExecutorManager.EXECUTOR_DEFAULT, DynamicPropertyFactory.getInstance().getStringProperty(ExecutorManager.KEY_EXECUTORS_DEFAULT, null).get()); }
@Test public void onBootEvent_change() { bootEvent.setEventType(EventType.BEFORE_PRODUCER_PROVIDER); listener.onBootEvent(bootEvent); Assert.assertEquals(ExecutorManager.EXECUTOR_REACTIVE, DynamicPropertyFactory.getInstance().getStringProperty(ExecutorManager.KEY_EXECUTORS_DEFAULT, null).get()); }
|
### Question:
CompatiblePathVersionMapper { public VersionRule getOrCreate(String pathVersion) { return mapper.computeIfAbsent(pathVersion, pv -> { return createVersionRule(pathVersion); }); } VersionRule getOrCreate(String pathVersion); }### Answer:
@Test public void getOrCreate() { VersionRule versionRule = mapper.getOrCreate("v1"); Assert.assertEquals("1.0.0.0-2.0.0.0", versionRule.getVersionRule()); }
@Test public void createVersionRule_empty() { expectedException.expect(ServiceCombException.class); expectedException.expectMessage(Matchers.is("pathVersion \"\" is invalid, format must be v+number or V+number.")); mapper.getOrCreate(""); }
@Test public void createVersionRule_invalidFormat() { expectedException.expect(ServiceCombException.class); expectedException.expectMessage(Matchers.is("pathVersion \"a1\" is invalid, format must be v+number or V+number.")); mapper.getOrCreate("a1"); }
@Test public void createVersionRule_invalidNumber() { expectedException.expect(ServiceCombException.class); expectedException.expectMessage(Matchers.is("pathVersion \"va\" is invalid, format must be v+number or V+number.")); mapper.getOrCreate("va"); }
@Test public void createVersionRule_tooSmall() { expectedException.expect(ServiceCombException.class); expectedException.expectMessage(Matchers.is("pathVersion \"v-1\" is invalid, version range is [0, 32767].")); mapper.getOrCreate("v-1"); }
@Test public void createVersionRule_tooBig() { expectedException.expect(ServiceCombException.class); expectedException.expectMessage(Matchers.is("pathVersion \"v32768\" is invalid, version range is [0, 32767].")); mapper.getOrCreate("v32768"); }
@Test public void createVersionRule_32767() { VersionRule versionRule = mapper.getOrCreate("v32767"); Assert.assertEquals("32767.0.0.0+", versionRule.getVersionRule()); }
|
### Question:
ZeroConfigClient { public boolean unregister() { ServerMicroserviceInstance foundInstance = preUnregisterCheck(); if (foundInstance == null) { LOGGER.warn( "Failed to unregister as Microservice Instance doesn't exist in server side in Zero-Config mode"); return false; } try { LOGGER.info( "Start Multicast Microservice Instance Unregister Event in Zero-Config mode. Service ID: {}, Instance ID:{}", foundInstance.getServiceId(), foundInstance.getInstanceId()); Map<String, String> unregisterEventMap = new HashMap<>(); unregisterEventMap.put(EVENT, UNREGISTER_EVENT); unregisterEventMap.put(SERVICE_ID, foundInstance.getServiceId()); unregisterEventMap.put(INSTANCE_ID, foundInstance.getInstanceId()); byte[] unregisterEventBytes = unregisterEventMap.toString().getBytes(ENCODE); DatagramPacket unregisterEventDataPacket = new DatagramPacket(unregisterEventBytes, unregisterEventBytes.length, InetAddress.getByName(GROUP), PORT); this.multicastSocket.send(unregisterEventDataPacket); return true; } catch (IOException e) { LOGGER.error( "Failed to Multicast Microservice Instance Unregister Event in Zero-Config mode. Service ID: {}, Instance ID:{}", foundInstance.getServiceId(), foundInstance.getInstanceId(), e); return false; } } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked(
ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName,
String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice(
Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance(
MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer:
@Test public void test_unregister_withCorrectData_UnregisterShouldSucceed() { when(zeroConfigRegistryService.findServiceInstance(selfServiceId, selfInstanceId)) .thenReturn(prepareServerServiceInstance(true)); boolean returnedResult = target.unregister(); Assert.assertTrue(returnedResult); }
@Test public void test_unregister_withWrongData_UnregisterShouldFail() { when(zeroConfigRegistryService.findServiceInstance(selfServiceId, selfInstanceId)) .thenReturn(null); boolean returnedResult = target.unregister(); Assert.assertFalse(returnedResult); }
@Test public void test_unregister_MulticastThrowException_UnregisterShouldFail() throws IOException { when(zeroConfigRegistryService.findServiceInstance(selfServiceId, selfInstanceId)) .thenReturn(prepareServerServiceInstance(true)); doThrow(IOException.class).when(multicastSocket).send(anyObject()); boolean returnedResult = target.unregister(); Assert.assertFalse(returnedResult); }
|
### Question:
InspectorBootListener implements BootListener { @Override public int getOrder() { return Short.MAX_VALUE; } @Override int getOrder(); @Override void onAfterTransport(BootEvent event); }### Answer:
@Test public void getOrder() { Assert.assertEquals(Short.MAX_VALUE, new InspectorBootListener().getOrder()); }
|
### Question:
InspectorImpl { @Path("/schemas") @GET public Collection<String> getSchemaIds() { return schemas.keySet(); } InspectorImpl(SCBEngine scbEngine, InspectorConfig inspectorConfig, Map<String, String> schemas); SCBEngine getScbEngine(); InspectorConfig getInspectorConfig(); void setPriorityPropertyManager(PriorityPropertyManager priorityPropertyManager); @Path("/schemas") @GET Collection<String> getSchemaIds(); @Path("/download/schemas") @GET @ApiResponse(code = 200, message = "", response = File.class) Response downloadSchemas(@QueryParam("format") SchemaFormat format); @Path("/schemas/{schemaId}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getSchemaContentById(@PathParam("schemaId") String schemaId,
@QueryParam("format") SchemaFormat format, @QueryParam("download") boolean download); @Path("/{path : .+}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getStaticResource(@PathParam("path") String path); @Path("/dynamicProperties") @GET List<DynamicPropertyView> dynamicProperties(); @Path("/priorityProperties") @GET List<PriorityPropertyView> priorityProperties(); }### Answer:
@Test public void getSchemaIds() { Assert.assertThat(inspector.getSchemaIds(), Matchers.contains("schema1", "schema2")); }
|
### Question:
InspectorImpl { @Path("/download/schemas") @GET @ApiResponse(code = 200, message = "", response = File.class) public Response downloadSchemas(@QueryParam("format") SchemaFormat format) { if (format == null) { format = SchemaFormat.SWAGGER; } ByteArrayOutputStream os = new ByteArrayOutputStream(); try (ZipOutputStream zos = new ZipOutputStream(os)) { for (Entry<String, String> entry : schemas.entrySet()) { zos.putNextEntry(new ZipEntry(entry.getKey() + format.getSuffix())); String content = entry.getValue(); if (SchemaFormat.HTML.equals(format)) { content = swaggerToHtml(content); } zos.write(content.getBytes(StandardCharsets.UTF_8)); zos.closeEntry(); } } catch (Throwable e) { String msg = "failed to create schemas zip file, format=" + format + "."; LOGGER.error(msg, e); return Response.failResp(new InvocationException(Status.INTERNAL_SERVER_ERROR, msg)); } Part part = new InputStreamPart(null, new ByteArrayInputStream(os.toByteArray())) .setSubmittedFileName( RegistrationManager.INSTANCE.getMicroservice().getServiceName() + format.getSuffix() + ".zip"); return Response.ok(part); } InspectorImpl(SCBEngine scbEngine, InspectorConfig inspectorConfig, Map<String, String> schemas); SCBEngine getScbEngine(); InspectorConfig getInspectorConfig(); void setPriorityPropertyManager(PriorityPropertyManager priorityPropertyManager); @Path("/schemas") @GET Collection<String> getSchemaIds(); @Path("/download/schemas") @GET @ApiResponse(code = 200, message = "", response = File.class) Response downloadSchemas(@QueryParam("format") SchemaFormat format); @Path("/schemas/{schemaId}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getSchemaContentById(@PathParam("schemaId") String schemaId,
@QueryParam("format") SchemaFormat format, @QueryParam("download") boolean download); @Path("/{path : .+}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getStaticResource(@PathParam("path") String path); @Path("/dynamicProperties") @GET List<DynamicPropertyView> dynamicProperties(); @Path("/priorityProperties") @GET List<PriorityPropertyView> priorityProperties(); }### Answer:
@Test public void downloadSchemas_html(@Mocked Microservice microservice) throws IOException { new Expectations(RegistrationManager.INSTANCE) { { RegistrationManager.INSTANCE.getMicroservice(); result = microservice; microservice.getServiceName(); result = "ms"; } }; Response response = inspector.downloadSchemas(SchemaFormat.HTML); Part part = response.getResult(); Assert.assertEquals("ms.html.zip", part.getSubmittedFileName()); try (InputStream is = part.getInputStream()) { Map<String, String> unziped = unzip(is); Assert.assertEquals(schemas.size(), unziped.size()); Assert.assertTrue(unziped.get("schema1.html").endsWith("</html>")); Assert.assertTrue(unziped.get("schema2.html").endsWith("</html>")); } }
@Test public void downloadSchemas_failed() { SchemaFormat format = SchemaFormat.SWAGGER; new Expectations(format) { { format.getSuffix(); result = new RuntimeExceptionWithoutStackTrace("zip failed."); } }; try (LogCollector logCollector = new LogCollector()) { Response response = inspector.downloadSchemas(format); Assert.assertEquals("failed to create schemas zip file, format=SWAGGER.", logCollector.getLastEvents().getMessage()); InvocationException invocationException = response.getResult(); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR, invocationException.getStatus()); Assert.assertEquals("failed to create schemas zip file, format=SWAGGER.", ((CommonExceptionData) invocationException.getErrorData()).getMessage()); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatusCode()); Assert.assertEquals(Status.INTERNAL_SERVER_ERROR.getReasonPhrase(), response.getReasonPhrase()); } }
|
### Question:
InspectorImpl { @Path("/schemas/{schemaId}") @GET @ApiResponse(code = 200, message = "", response = File.class) public Response getSchemaContentById(@PathParam("schemaId") String schemaId, @QueryParam("format") SchemaFormat format, @QueryParam("download") boolean download) { String swaggerContent = schemas.get(schemaId); if (swaggerContent == null) { return Response.failResp(new InvocationException(Status.NOT_FOUND, Status.NOT_FOUND.getReasonPhrase())); } if (format == null) { format = SchemaFormat.SWAGGER; } byte[] bytes; if (SchemaFormat.HTML.equals(format)) { String html = swaggerToHtml(swaggerContent); bytes = html.getBytes(StandardCharsets.UTF_8); } else { bytes = swaggerContent.getBytes(StandardCharsets.UTF_8); } Part part = new InputStreamPart(null, new ByteArrayInputStream(bytes)) .setSubmittedFileName(schemaId + format.getSuffix()); Response response = Response.ok(part); if (!download) { response.getHeaders().addHeader(HttpHeaders.CONTENT_DISPOSITION, "inline"); } response.getHeaders().addHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_HTML); return response; } InspectorImpl(SCBEngine scbEngine, InspectorConfig inspectorConfig, Map<String, String> schemas); SCBEngine getScbEngine(); InspectorConfig getInspectorConfig(); void setPriorityPropertyManager(PriorityPropertyManager priorityPropertyManager); @Path("/schemas") @GET Collection<String> getSchemaIds(); @Path("/download/schemas") @GET @ApiResponse(code = 200, message = "", response = File.class) Response downloadSchemas(@QueryParam("format") SchemaFormat format); @Path("/schemas/{schemaId}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getSchemaContentById(@PathParam("schemaId") String schemaId,
@QueryParam("format") SchemaFormat format, @QueryParam("download") boolean download); @Path("/{path : .+}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getStaticResource(@PathParam("path") String path); @Path("/dynamicProperties") @GET List<DynamicPropertyView> dynamicProperties(); @Path("/priorityProperties") @GET List<PriorityPropertyView> priorityProperties(); }### Answer:
@Test public void getSchemaContentById_notExist() { Response response = inspector.getSchemaContentById("notExist", null, false); InvocationException invocationException = response.getResult(); Assert.assertEquals(Status.NOT_FOUND, invocationException.getStatus()); Assert.assertEquals(Status.NOT_FOUND.getReasonPhrase(), ((CommonExceptionData) invocationException.getErrorData()).getMessage()); Assert.assertEquals(404, response.getStatusCode()); Assert.assertEquals("Not Found", response.getReasonPhrase()); }
|
### Question:
InspectorImpl { @Path("/{path : .+}") @GET @ApiResponse(code = 200, message = "", response = File.class) public Response getStaticResource(@PathParam("path") String path) { return resourceHandler.handle(path); } InspectorImpl(SCBEngine scbEngine, InspectorConfig inspectorConfig, Map<String, String> schemas); SCBEngine getScbEngine(); InspectorConfig getInspectorConfig(); void setPriorityPropertyManager(PriorityPropertyManager priorityPropertyManager); @Path("/schemas") @GET Collection<String> getSchemaIds(); @Path("/download/schemas") @GET @ApiResponse(code = 200, message = "", response = File.class) Response downloadSchemas(@QueryParam("format") SchemaFormat format); @Path("/schemas/{schemaId}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getSchemaContentById(@PathParam("schemaId") String schemaId,
@QueryParam("format") SchemaFormat format, @QueryParam("download") boolean download); @Path("/{path : .+}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getStaticResource(@PathParam("path") String path); @Path("/dynamicProperties") @GET List<DynamicPropertyView> dynamicProperties(); @Path("/priorityProperties") @GET List<PriorityPropertyView> priorityProperties(); }### Answer:
@Test public void getStaticResource_notExist() throws IOException { Response response = inspector.getStaticResource("notExist"); InvocationException invocationException = response.getResult(); Assert.assertEquals(Status.NOT_FOUND, invocationException.getStatus()); Assert.assertEquals(Status.NOT_FOUND.getReasonPhrase(), ((CommonExceptionData) invocationException.getErrorData()).getMessage()); Assert.assertEquals(404, response.getStatusCode()); Assert.assertEquals("Not Found", response.getReasonPhrase()); }
@Test public void getStaticResource() throws IOException { Response response = inspector.getStaticResource("index.html"); Part part = response.getResult(); Assert.assertEquals("inline", response.getHeaders().getFirst(HttpHeaders.CONTENT_DISPOSITION)); Assert.assertEquals(MediaType.TEXT_HTML, response.getHeaders().getFirst(HttpHeaders.CONTENT_TYPE)); try (InputStream is = part.getInputStream()) { Assert.assertTrue(IOUtils.toString(is, StandardCharsets.UTF_8).endsWith("</html>")); } }
|
### Question:
InspectorImpl { @Path("/dynamicProperties") @GET public List<DynamicPropertyView> dynamicProperties() { List<DynamicPropertyView> views = new ArrayList<>(); for (DynamicProperty property : ConfigUtil.getAllDynamicProperties().values()) { views.add(createDynamicPropertyView(property)); } views.sort(Comparator .comparing(DynamicPropertyView::getCallbackCount) .thenComparing(DynamicPropertyView::getChangedTime).reversed() .thenComparing(DynamicPropertyView::getKey)); return views; } InspectorImpl(SCBEngine scbEngine, InspectorConfig inspectorConfig, Map<String, String> schemas); SCBEngine getScbEngine(); InspectorConfig getInspectorConfig(); void setPriorityPropertyManager(PriorityPropertyManager priorityPropertyManager); @Path("/schemas") @GET Collection<String> getSchemaIds(); @Path("/download/schemas") @GET @ApiResponse(code = 200, message = "", response = File.class) Response downloadSchemas(@QueryParam("format") SchemaFormat format); @Path("/schemas/{schemaId}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getSchemaContentById(@PathParam("schemaId") String schemaId,
@QueryParam("format") SchemaFormat format, @QueryParam("download") boolean download); @Path("/{path : .+}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getStaticResource(@PathParam("path") String path); @Path("/dynamicProperties") @GET List<DynamicPropertyView> dynamicProperties(); @Path("/priorityProperties") @GET List<PriorityPropertyView> priorityProperties(); }### Answer:
@Test public void dynamicProperties() { DynamicProperty.getInstance("zzz"); ArchaiusUtils.setProperty("zzz", "abc"); DynamicProperty.getInstance("yyy").addCallback(() -> { }); List<DynamicPropertyView> views = inspector.dynamicProperties(); Map<String, DynamicPropertyView> viewMap = views.stream() .collect(Collectors.toMap(DynamicPropertyView::getKey, Function.identity())); Assert.assertEquals(1, viewMap.get("yyy").getCallbackCount()); Assert.assertEquals(0, viewMap.get("zzz").getCallbackCount()); Assert.assertEquals(0, viewMap.get("servicecomb.inspector.enabled").getCallbackCount()); Assert.assertEquals(0, viewMap.get("servicecomb.inspector.swagger.html.asciidoctorCss").getCallbackCount()); int count = ConfigUtil.getAllDynamicProperties().size(); ConfigUtil.getAllDynamicProperties().remove("yyy"); ConfigUtil.getAllDynamicProperties().remove("zzz"); Assert.assertEquals(count - 2, ConfigUtil.getAllDynamicProperties().size()); }
|
### Question:
InspectorImpl { @Path("/priorityProperties") @GET public List<PriorityPropertyView> priorityProperties() { List<PriorityPropertyView> views = new ArrayList<>(); priorityPropertyManager.getConfigObjectMap().values().stream() .flatMap(Collection::stream) .forEach(p -> views.add(createPriorityPropertyView(p))); priorityPropertyManager.getPriorityPropertySet().forEach(p -> views.add(createPriorityPropertyView(p))); return views; } InspectorImpl(SCBEngine scbEngine, InspectorConfig inspectorConfig, Map<String, String> schemas); SCBEngine getScbEngine(); InspectorConfig getInspectorConfig(); void setPriorityPropertyManager(PriorityPropertyManager priorityPropertyManager); @Path("/schemas") @GET Collection<String> getSchemaIds(); @Path("/download/schemas") @GET @ApiResponse(code = 200, message = "", response = File.class) Response downloadSchemas(@QueryParam("format") SchemaFormat format); @Path("/schemas/{schemaId}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getSchemaContentById(@PathParam("schemaId") String schemaId,
@QueryParam("format") SchemaFormat format, @QueryParam("download") boolean download); @Path("/{path : .+}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getStaticResource(@PathParam("path") String path); @Path("/dynamicProperties") @GET List<DynamicPropertyView> dynamicProperties(); @Path("/priorityProperties") @GET List<PriorityPropertyView> priorityProperties(); }### Answer:
@Test public void priorityProperties() { PriorityPropertyManager priorityPropertyManager = new PriorityPropertyManager(); inspector.setPriorityPropertyManager(priorityPropertyManager); PriorityProperty<?> priorityProperty = priorityPropertyManager .createPriorityProperty(int.class, 0, 0, "high", "low"); List<PriorityPropertyView> views = inspector.priorityProperties(); Assert.assertEquals(1, views.size()); Assert.assertThat( views.get(0).getDynamicProperties().stream().map(DynamicPropertyView::getKey).collect(Collectors.toList()), Matchers.contains("high", "low")); priorityPropertyManager.close(); inspector.setPriorityPropertyManager(null); }
|
### Question:
Exceptions { public static InvocationException convert(@Nonnull Invocation invocation, Throwable throwable) { StatusType genericStatus = getGenericStatus(invocation); return convert(invocation, throwable, genericStatus); } private Exceptions(); static Throwable unwrapIncludeInvocationException(Throwable throwable); static T unwrap(Throwable throwable); static InvocationException create(StatusType status, Object errorData); static InvocationException create(StatusType status, String code, String msg); static InvocationException consumer(String code, String msg); static InvocationException consumer(String code, String msg, Throwable cause); static InvocationException genericConsumer(String msg); static InvocationException genericConsumer(String msg, Throwable cause); static InvocationException producer(String code, String msg); static InvocationException producer(String code, String msg, Throwable cause); static InvocationException genericProducer(String msg); static InvocationException genericProducer(String msg, Throwable cause); static StatusType getGenericStatus(@Nonnull Invocation invocation); static Response exceptionToResponse(@Nullable Invocation invocation, Throwable exception,
StatusType genericStatus); static InvocationException convert(@Nonnull Invocation invocation, Throwable throwable); static InvocationException convert(@Nullable Invocation invocation, Throwable throwable,
StatusType genericStatus); }### Answer:
@Test void should_convert_unknown_client_exception_to_invocation_exception() { IllegalStateException exception = new IllegalStateException("msg"); InvocationException invocationException = Exceptions.convert(null, exception, BAD_REQUEST); assertThat(invocationException).hasCause(exception); assertThat(invocationException.getStatus()).isEqualTo(BAD_REQUEST); assertThat(invocationException.getErrorData()).isInstanceOf(CommonExceptionData.class); assertThat(Json.encode(invocationException.getErrorData())) .isEqualTo("{\"code\":\"SCB.00000000\",\"message\":\"msg\"}"); }
@Test void should_convert_unknown_server_exception_to_invocation_exception() { IllegalStateException exception = new IllegalStateException("msg"); InvocationException invocationException = Exceptions.convert(null, exception, INTERNAL_SERVER_ERROR); assertThat(invocationException).hasCause(exception); assertThat(invocationException.getStatus()).isEqualTo(INTERNAL_SERVER_ERROR); assertThat(invocationException.getErrorData()).isInstanceOf(CommonExceptionData.class); assertThat(Json.encode(invocationException.getErrorData())) .isEqualTo("{\"code\":\"SCB.50000000\",\"message\":\"msg\"}"); }
|
### Question:
ExecutorManager { public Executor findExecutor(OperationMeta operationMeta) { return findExecutor(operationMeta, null); } ExecutorManager(); void registerExecutor(String id, Executor executor); Executor findExecutor(OperationMeta operationMeta); Executor findExecutor(OperationMeta operationMeta, Executor defaultOperationExecutor); Executor findExecutorById(String id); static final String KEY_EXECUTORS_PREFIX; static final String KEY_EXECUTORS_DEFAULT; static final String EXECUTOR_GROUP_THREADPOOL; static final String EXECUTOR_REACTIVE; static final String EXECUTOR_DEFAULT; }### Answer:
@Test public void findExecutor_oneParam(@Mocked Executor executor, @Mocked OperationMeta operationMeta) { new Expectations(BeanUtils.class) { { BeanUtils.getBean(ExecutorManager.EXECUTOR_DEFAULT); result = executor; } }; Assert.assertSame(executor, new ExecutorManager().findExecutor(operationMeta)); }
@Test public void findExecutor_twoParam_opCfg_withoutOpDef(@Mocked Executor executor, @Mocked OperationMeta operationMeta) { String schemaQualifiedName = "schemaId.opId"; String opBeanId = "opBeanId"; ArchaiusUtils.setProperty(ExecutorManager.KEY_EXECUTORS_PREFIX + schemaQualifiedName, opBeanId); new Expectations(BeanUtils.class) { { operationMeta.getSchemaQualifiedName(); result = schemaQualifiedName; BeanUtils.getBean(opBeanId); result = executor; } }; Assert.assertSame(executor, new ExecutorManager().findExecutor(operationMeta, null)); }
@Test public void findExecutor_twoParam_opCfg_withOpDef(@Mocked Executor executor, @Mocked Executor defExecutor, @Mocked OperationMeta operationMeta) { String schemaQualifiedName = "schemaId.opId"; String opBeanId = "opBeanId"; ArchaiusUtils.setProperty(ExecutorManager.KEY_EXECUTORS_PREFIX + schemaQualifiedName, opBeanId); new Expectations(BeanUtils.class) { { operationMeta.getSchemaQualifiedName(); result = schemaQualifiedName; BeanUtils.getBean(opBeanId); result = executor; } }; Assert.assertSame(executor, new ExecutorManager().findExecutor(operationMeta, defExecutor)); }
@Test public void findExecutor_twoParam_schemaCfg_withOpDef(@Mocked OperationMeta operationMeta, @Mocked Executor defExecutor) { Assert.assertSame(defExecutor, new ExecutorManager().findExecutor(operationMeta, defExecutor)); }
@Test public void findExecutor_twoParam_schemaCfg_withoutOpDef(@Mocked Executor executor, @Mocked OperationMeta operationMeta) { String schemaName = "schemaId"; String opBeanId = "opBeanId"; ArchaiusUtils.setProperty(ExecutorManager.KEY_EXECUTORS_PREFIX + schemaName, opBeanId); new Expectations(BeanUtils.class) { { operationMeta.getSchemaId(); result = schemaName; BeanUtils.getBean(opBeanId); result = executor; } }; Assert.assertSame(executor, new ExecutorManager().findExecutor(operationMeta, null)); }
@Test public void findExecutor_twoParam_defaultCfg(@Mocked Executor executor, @Mocked SchemaMeta schemaMeta, @Mocked OperationMeta operationMeta) { String beanId = "beanId"; ArchaiusUtils.setProperty(ExecutorManager.KEY_EXECUTORS_DEFAULT, beanId); new Expectations(BeanUtils.class) { { BeanUtils.getBean(beanId); result = executor; } }; Assert.assertSame(executor, new ExecutorManager().findExecutor(operationMeta, null)); }
|
### Question:
ZeroConfigClient { public Microservice getMicroservice(String microserviceId) { if (selfMicroservice.getServiceId().equals(microserviceId)) { return selfMicroservice; } else { return ClientUtil .convertToClientMicroservice(zeroConfigRegistryService.getMicroservice(microserviceId)); } } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked(
ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName,
String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice(
Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance(
MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer:
@Test public void test_getMicroservice_forOtherService_shouldCallZeroConfigRegistryService() { when(zeroConfigRegistryService.getMicroservice(otherServiceId)) .thenReturn(prepareServerServiceInstance(true)); Microservice returnedResult = target.getMicroservice(otherServiceId); Assert.assertEquals(otherServiceId, returnedResult.getServiceId()); verify(zeroConfigRegistryService, times(1)).getMicroservice(otherServiceId); }
|
### Question:
AbstractTransport implements Transport { protected void setListenAddressWithoutSchema(String addressWithoutSchema) { setListenAddressWithoutSchema(addressWithoutSchema, null); } @Override Endpoint getPublishEndpoint(); @Override Endpoint getEndpoint(); @Override Object parseAddress(String address); static final String ENDPOINT_KEY; }### Answer:
@Test(expected = IllegalArgumentException.class) public void testMyAbstractTransportException(@Mocked TransportManager manager) { MyAbstractTransport transport = new MyAbstractTransport(); transport.setListenAddressWithoutSchema(":127.0.0.1:9090"); }
|
### Question:
TransportManager { protected Map<String, List<Transport>> groupByName() { Map<String, List<Transport>> groups = new HashMap<>(); for (Transport transport : transports) { List<Transport> list = groups.computeIfAbsent(transport.getName(), name -> new ArrayList<>()); list.add(transport); } return groups; } void clearTransportBeforeInit(); void addTransportBeforeInit(Transport transport); void addTransportsBeforeInit(List<Transport> transports); void init(SCBEngine scbEngine); Transport findTransport(String transportName); }### Answer:
@Test public void testGroupByName(@Mocked Transport t1, @Mocked Transport t2_1, @Mocked Transport t2_2) { new Expectations() { { t1.getName(); result = "t1"; t2_1.getName(); result = "t2"; t2_2.getName(); result = "t2"; } }; TransportManager manager = new TransportManager(); manager.addTransportsBeforeInit(Arrays.asList(t1, t2_1, t2_2)); Map<String, List<Transport>> groups = manager.groupByName(); Assert.assertEquals(2, groups.size()); Assert.assertEquals(1, groups.get("t1").size()); Assert.assertEquals(t1, groups.get("t1").get(0)); Assert.assertEquals(2, groups.get("t2").size()); Assert.assertEquals(t2_1, groups.get("t2").get(0)); Assert.assertEquals(t2_2, groups.get("t2").get(1)); }
|
### Question:
TransportManager { protected void checkTransportGroup(List<Transport> group) { Map<Integer, Transport> orderMap = new HashMap<>(); for (Transport transport : group) { Transport existTransport = orderMap.putIfAbsent(transport.getOrder(), transport); if (existTransport != null) { throw new ServiceCombException(String.format("%s and %s have the same order %d", existTransport.getClass().getName(), transport.getClass().getName(), transport.getOrder())); } } } void clearTransportBeforeInit(); void addTransportBeforeInit(Transport transport); void addTransportsBeforeInit(List<Transport> transports); void init(SCBEngine scbEngine); Transport findTransport(String transportName); }### Answer:
@Test public void testCheckTransportGroupInvalid(@Mocked Transport t1, @Mocked Transport t2) { new Expectations() { { t1.getOrder(); result = 1; t2.getOrder(); result = 1; } }; TransportManager manager = new TransportManager(); List<Transport> group = Arrays.asList(t1, t2); try { manager.checkTransportGroup(group); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals( "org.apache.servicecomb.core.$Impl_Transport and org.apache.servicecomb.core.$Impl_Transport have the same order 1", e.getMessage()); } }
@Test public void testCheckTransportGroupValid(@Mocked Transport t1, @Mocked Transport t2) { new Expectations() { { t1.getOrder(); result = 1; t2.getOrder(); result = 2; } }; TransportManager manager = new TransportManager(); List<Transport> group = Arrays.asList(t1, t2); try { manager.checkTransportGroup(group); } catch (ServiceCombException e) { Assert.fail("must not throw exception: " + e.getMessage()); } }
|
### Question:
TransportManager { protected Transport chooseOneTransport(List<Transport> group) { group.sort(Comparator.comparingInt(Transport::getOrder)); for (Transport transport : group) { if (transport.canInit()) { LOGGER.info("choose {} for {}.", transport.getClass().getName(), transport.getName()); return transport; } } throw new ServiceCombException( String.format("all transport named %s refused to init.", group.get(0).getName())); } void clearTransportBeforeInit(); void addTransportBeforeInit(Transport transport); void addTransportsBeforeInit(List<Transport> transports); void init(SCBEngine scbEngine); Transport findTransport(String transportName); }### Answer:
@Test public void testChooseOneTransportFirst(@Mocked Transport t1, @Mocked Transport t2) { new Expectations() { { t1.getOrder(); result = 1; t1.canInit(); result = true; t2.getOrder(); result = 2; } }; TransportManager manager = new TransportManager(); List<Transport> group = Arrays.asList(t1, t2); Assert.assertEquals(t1, manager.chooseOneTransport(group)); }
@Test public void testChooseOneTransportSecond(@Mocked Transport t1, @Mocked Transport t2) { new Expectations() { { t1.getOrder(); result = Integer.MAX_VALUE; t1.canInit(); result = true; t2.getOrder(); result = -1000; t2.canInit(); result = false; } }; TransportManager manager = new TransportManager(); List<Transport> group = Arrays.asList(t1, t2); Assert.assertEquals(t1, manager.chooseOneTransport(group)); }
@Test public void testChooseOneTransportNone(@Mocked Transport t1, @Mocked Transport t2) { new Expectations() { { t1.getName(); result = "t"; t1.getOrder(); result = 1; t1.canInit(); result = false; t2.getOrder(); result = 2; t2.canInit(); result = false; } }; TransportManager manager = new TransportManager(); List<Transport> group = Arrays.asList(t1, t2); try { manager.chooseOneTransport(group); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("all transport named t refused to init.", e.getMessage()); } }
|
### Question:
FilterChainsManager { public List<Filter> createConsumerFilters(String microservice) { return createFilters(consumerChainsConfig, microservice); } @Autowired FilterChainsManager setTransportFiltersConfig(TransportFiltersConfig transportFiltersConfig); @Value("${servicecomb.filter-chains.enabled:false}") FilterChainsManager setEnabled(boolean enabled); FilterManager getFilterManager(); @Autowired FilterChainsManager setFilterManager(FilterManager filterManager); FilterChainsManager init(SCBEngine engine); boolean isEnabled(); FilterChainsManager addProviders(FilterProvider... providers); FilterChainsManager addProviders(Collection<FilterProvider> providers); FilterNode createConsumerFilterChain(String microservice); FilterNode createProducerFilterChain(String microservice); List<Filter> createConsumerFilters(String microservice); List<Filter> createProducerFilters(String microservice); String collectResolvedChains(); }### Answer:
@Test public void should_allow_not_share_filter_instance() { default_chain("simple-load-balance"); FilterChainsManager filterChains = createFilterChains(); List<Filter> aFilters = filterChains.createConsumerFilters("a"); List<Filter> bFilters = filterChains.createConsumerFilters("b"); assertThat(aFilters.get(0)).isNotSameAs(bFilters.get(0)); }
@Test public void should_allow_share_filter_instance() { default_chain("simple-retry"); FilterChainsManager filterChains = createFilterChains(); List<Filter> aFilters = filterChains.createConsumerFilters("a"); List<Filter> bFilters = filterChains.createConsumerFilters("b"); assertThat(aFilters).hasSameElementsAs(bFilters); }
@Test public void should_allow_mix_share_and_not_share_filter_instance() { default_chain("simple-load-balance, simple-retry"); FilterChainsManager filterChains = createFilterChains(); List<Filter> aFilters = filterChains.createConsumerFilters("a"); List<Filter> bFilters = filterChains.createConsumerFilters("b"); assertThat(aFilters.get(0)).isNotSameAs(bFilters.get(0)); assertThat(aFilters.get(1)).isSameAs(bFilters.get(1)); }
@Test public void microservice_scope_should_override_default_scope() { default_chain("simple-load-balance"); microservice_chain("a", "simple-retry"); FilterChainsManager filterChains = createFilterChains(); List<Filter> filters = filterChains.createConsumerFilters("a"); assertThat(filters.get(0)).isInstanceOf(SimpleRetryFilter.class); }
|
### Question:
ZeroConfigClient { public String getSchema(String microserviceId, String schemaId) { LOGGER.info("Retrieve schema content for Microservice ID: {}, Schema ID: {}", microserviceId, schemaId); if (selfMicroservice.getServiceId().equals(microserviceId)) { return selfMicroservice.getSchemaMap().computeIfPresent(schemaId, (k, v) -> v); } else { return null; } } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked(
ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName,
String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice(
Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance(
MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer:
@Test public void test_getSchema_forSelfMicroservice_shouldNotCallZeroConfigRegistryService_And_Succeed() { String returnedResult = target.getSchema(selfServiceId, schemaId1); Assert.assertEquals(schemaContent1, returnedResult); verifyZeroInteractions(zeroConfigRegistryService); }
@Test public void test_getSchema_forOtherMicroservice_shouldReturnNull() { String returnedResult = target.getSchema(otherServiceId, schemaId1); Assert.assertNull(returnedResult); }
|
### Question:
SimpleLoadBalanceFilter implements Filter { @Override public CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode) { if (invocation.getEndpoint() != null) { return nextNode.onFilter(invocation); } invocation.setEndpoint(selectEndpoint(invocation)); return nextNode.onFilter(invocation); } SimpleLoadBalanceFilter(); @Override CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode); Endpoint selectEndpoint(Invocation invocation); }### Answer:
@Test public void should_invoke_next_directly_when_invocation_already_has_endpoint() throws ExecutionException, InterruptedException { Response response = Response.ok("ok"); new Expectations() { { invocation.getEndpoint(); result = endpoint; nextNode.onFilter(invocation); result = CompletableFuture.completedFuture(response); } }; Response result = filter.onFilter(invocation, nextNode).get(); assertThat(result).isSameAs(response); new Verifications() { { discoveryContext.setInputParameters(invocation); times = 0; } }; }
|
### Question:
ProducerOperationFilter implements Filter { @Override public CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode) { invocation.onBusinessMethodStart(); SwaggerProducerOperation producerOperation = invocation.getOperationMeta().getSwaggerProducerOperation(); Object instance = producerOperation.getProducerInstance(); Method method = producerOperation.getProducerMethod(); Object[] args = invocation.toProducerArguments(); return invoke(invocation, instance, method, args) .thenApply(result -> convertResultToResponse(invocation, producerOperation, result)) .whenComplete((response, throwable) -> whenComplete(invocation, throwable)); } @Override CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode); }### Answer:
@Test public void should_record_invocation_trace_time() throws NoSuchMethodException { setInvokeSyncMethod(); filter.onFilter(invocation, FilterNode.EMPTY); new Verifications() { { invocation.onBusinessMethodStart(); times = 1; invocation.onBusinessMethodFinish(); times = 1; invocation.onBusinessFinish(); times = 1; } }; }
@Test public void should_provide_thread_local_invocation_context_for_sync_method() throws NoSuchMethodException { setInvokeSyncMethod(); filter.onFilter(invocation, FilterNode.EMPTY); assertThat(threadInvocationContext).isSameAs(invocation); }
@Test public void should_clear_thread_local_invocation_context_after_sync_method() throws NoSuchMethodException { setInvokeSyncMethod(); filter.onFilter(invocation, FilterNode.EMPTY); assertThat(ContextUtils.getInvocationContext()).isNull(); }
@Test public void should_catch_sync_business_exception() throws NoSuchMethodException { setInvokeMethod("syncException"); CompletableFuture<Response> future = filter.onFilter(invocation, FilterNode.EMPTY); assertThat(future).hasFailedWithThrowableThat() .isInstanceOf(RuntimeExceptionWithoutStackTrace.class) .hasMessage("syncException"); }
@Test public void should_provide_thread_local_invocation_context_for_async_method() throws NoSuchMethodException { setInvokeAsyncMethod(); filter.onFilter(invocation, FilterNode.EMPTY); assertThat(threadInvocationContext).isSameAs(invocation); }
@Test public void should_clear_thread_local_invocation_context_after_async_method() throws NoSuchMethodException { setInvokeAsyncMethod(); filter.onFilter(invocation, FilterNode.EMPTY); assertThat(ContextUtils.getInvocationContext()).isNull(); }
@Test public void should_catch_async_business_exception() throws NoSuchMethodException { setInvokeMethod("asyncException"); CompletableFuture<Response> future = filter.onFilter(invocation, FilterNode.EMPTY); assertThat(future).hasFailedWithThrowableThat() .isInstanceOf(RuntimeExceptionWithoutStackTrace.class) .hasMessage("asyncException"); }
@Test public void should_unify_IllegalArgumentException_message_when_convert_exception() throws NoSuchMethodException { setInvokeSyncMethod(); new Expectations() { { invocation.toProducerArguments(); result = new Object[] {1}; } }; CompletableFuture<Response> future = filter.onFilter(invocation, FilterNode.EMPTY); assertThat(future).hasFailedWithThrowableThat() .isInstanceOf(IllegalArgumentException.class) .hasMessage("wrong number of arguments"); InvocationException throwable = Exceptions .convert(invocation, catchThrowable(() -> future.get()), INTERNAL_SERVER_ERROR); assertThat(throwable).hasCauseInstanceOf(IllegalArgumentException.class); CommonExceptionData data = (CommonExceptionData) throwable.getErrorData(); assertThat(data.getMessage()).isEqualTo("Parameters not valid or types not match."); }
|
### Question:
ThreadPoolMetersInitializer implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { registry = globalRegistry.getDefaultRegistry(); createThreadPoolMeters(); } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); void createThreadPoolMeters(); static String REJECTED_COUNT; }### Answer:
@Test public void init() { new Expectations(SCBEngine.class) { { SCBEngine.getInstance().getProducerMicroserviceMeta(); result = microserviceMeta; } }; Map<String, Executor> beanExecutors = new HashMap<>(); beanExecutors.put("executor", executor); beanExecutors.put("groupExecutor", groupExecutor); beanExecutors.put("threadPoolExecutor", threadPoolExecutor); new Expectations(BeanUtils.class) { { BeanUtils.getContext(); result = applicationContext; applicationContext.getBeansOfType(Executor.class); result = beanExecutors; } }; Mockito.when(threadPoolExecutor.getQueue()).thenReturn(queue); new Expectations() { { microserviceMeta.getOperations(); result = Arrays.asList(operationMetaExecutor, operationMetaSameExecutor, operationMetaFixedThreadExecutor); operationMetaExecutor.getExecutor(); result = executor; operationMetaSameExecutor.getExecutor(); result = executor; operationMetaFixedThreadExecutor.getExecutor(); result = groupExecutor; groupExecutor.getExecutorList(); result = Arrays.asList(threadPoolExecutor); queue.size(); result = 10d; } }; new MockUp<ScheduledThreadPoolExecutor>() { @Mock void delayedExecute(RunnableScheduledFuture<?> task) { } }; globalRegistry.add(registry); threadPoolMetersInitializer.init(globalRegistry, null, null); PolledMeter.update(registry); List<String> result = new ArrayList<>(); registry.iterator().forEachRemaining(meter -> { result.add(meter.measure().toString()); }); Assert.assertThat(result, Matchers.containsInAnyOrder("[Measurement(threadpool.maxThreads:id=groupExecutor-group0,0,0.0)]", "[Measurement(threadpool.completedTaskCount:id=groupExecutor-group0,0,0.0)]", "[Measurement(threadpool.currentThreadsBusy:id=groupExecutor-group0,0,0.0)]", "[Measurement(threadpool.corePoolSize:id=groupExecutor-group0,0,0.0)]", "[Measurement(threadpool.poolSize:id=groupExecutor-group0,0,0.0)]", "[Measurement(threadpool.queueSize:id=groupExecutor-group0,0,10.0)]", "[Measurement(threadpool.taskCount:id=groupExecutor-group0,0,0.0)]")); }
|
### Question:
ProducerInvocationFlow { public void run() { CompletableFuture.completedFuture(null) .thenApply(v -> invocationCreator.create()) .exceptionally(this::sendCreateInvocationException) .thenAccept(this::tryRunInvocation); } ProducerInvocationFlow(InvocationCreator invocationCreator); ProducerInvocationFlow(InvocationCreator invocationCreator,
HttpServletRequestEx requestEx, HttpServletResponseEx responseEx); void run(); }### Answer:
@Test public void should_send_exception_response_when_failed_to_create_invocation() { RuntimeException exception = new RuntimeExceptionWithoutStackTrace(); TestFlow flow = new TestFlow(() -> { throw exception; }); flow.run(); assertThat(sendException).isSameAs(exception); }
@Test public void should_start_invocation_when_succeed_to_create_invocation() { mockFilterChain(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); new Verifications() { { invocation.onStart((HttpServletRequestEx) any, anyLong); times = 1; } }; }
@Test public void should_send_response_when_invocation_success() { mockFilterChain(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); assertThat(sendInvocation).isSameAs(invocation); }
@Test public void should_finish_invocation_when_invocation_success() { mockFilterChain(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); new Verifications() { { invocation.onFinish((Response) any); times = 1; } }; }
@Test public void should_send_response_when_invocation_fail() { mockInvocationFailed(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); assertThat(sendInvocation).isSameAs(invocation); }
@Test public void should_finish_invocation_when_invocation_fail() { mockInvocationFailed(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); new Verifications() { { invocation.onFinish((Response) any); times = 1; } }; }
|
### Question:
ProducerProviderManager { public void init() { registerProducerMetas(producerMetas); for (ProducerProvider provider : producerProviderList) { List<ProducerMeta> producerMetas = provider.init(); if (producerMetas == null) { LOGGER.warn("ProducerProvider {} not provide any producer.", provider.getClass().getName()); continue; } registerProducerMetas(producerMetas); } } ProducerProviderManager(SCBEngine scbEngine); List<ProducerProvider> getProducerProviderList(); void init(); void addProducerMeta(String schemaId, Object instance); void addProducerMeta(ProducerMeta producerMeta); SchemaMeta registerSchema(String schemaId, Object instance); SchemaMeta registerSchema(String schemaId, Class<?> schemaInterface, Object instance); }### Answer:
@Test public void allowedNoProvider() { new ProducerProviderManager(null).init(); }
|
### Question:
EndpointDiscoveryFilter extends AbstractEndpointDiscoveryFilter { @Override public int getOrder() { return Short.MAX_VALUE; } @Override int getOrder(); }### Answer:
@Test public void getOrder() { Assert.assertEquals(Short.MAX_VALUE, filter.getOrder()); }
|
### Question:
ZeroConfigClient { public MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId) { ServerMicroserviceInstance instance = this.zeroConfigRegistryService .findServiceInstance(serviceId, instanceId); if (instance == null) { LOGGER.error( "Invalid serviceId OR instanceId! Failed to retrieve Microservice Instance for serviceId {} and instanceId {}", serviceId, instanceId); return null; } return ClientUtil.convertToClientMicroserviceInstance(instance); } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked(
ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName,
String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice(
Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance(
MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer:
@Test public void test_findMicroserviceInstance_forNonExistInstance_shouldReturnNull() { when(zeroConfigRegistryService.findServiceInstance(selfServiceId, selfInstanceId)) .thenReturn(null); MicroserviceInstance returnedResult = target .findMicroserviceInstance(selfServiceId, selfInstanceId); Assert.assertNull(returnedResult); }
@Test public void test_findMicroServiceInstance_forExistInstance_shouldReturnInstance() { when(zeroConfigRegistryService.findServiceInstance(otherServiceId, selfInstanceId)) .thenReturn(prepareServerServiceInstance(true)); MicroserviceInstance returnedResult = target .findMicroserviceInstance(otherServiceId, selfInstanceId); Assert.assertNotNull(returnedResult); Assert.assertEquals(otherServiceId, returnedResult.getServiceId()); Assert.assertEquals(selfInstanceId, returnedResult.getInstanceId()); }
|
### Question:
EndpointDiscoveryFilter extends AbstractEndpointDiscoveryFilter { @Override protected String findTransportName(DiscoveryContext context, DiscoveryTreeNode parent) { Invocation invocation = context.getInputParameters(); return invocation.getConfigTransportName(); } @Override int getOrder(); }### Answer:
@Test public void getTransportName() { new Expectations() { { invocation.getConfigTransportName(); result = Const.RESTFUL; } }; Assert.assertEquals(Const.RESTFUL, filter.findTransportName(context, null)); }
|
### Question:
EndpointDiscoveryFilter extends AbstractEndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new Endpoint(transport, endpoint, instance); } @Override int getOrder(); }### Answer:
@Test public void createEndpointNullTransport() { Assert.assertNull(filter.createEndpoint(Const.RESTFUL, "", null)); }
@Test public void createEndpointNormal(@Mocked Transport transport, @Mocked MicroserviceInstance instance) { String endpoint = "rest: Object address = new Object(); new Expectations(scbEngine.getTransportManager()) { { scbEngine.getTransportManager().findTransport(Const.RESTFUL); result = transport; transport.parseAddress(endpoint); result = address; } }; Endpoint ep = (Endpoint) filter.createEndpoint(Const.RESTFUL, endpoint, instance); Assert.assertSame(transport, ep.getTransport()); Assert.assertSame(address, ep.getAddress()); Assert.assertSame(instance, ep.getMicroserviceInstance()); Assert.assertEquals(endpoint, ep.getEndpoint()); }
|
### Question:
Endpoint { public Endpoint(Transport transport, String endpoint) { this(transport, endpoint, null); } Endpoint(Transport transport, String endpoint); Endpoint(Transport transport, String endpoint, MicroserviceInstance instance); Endpoint(Transport transport, String endpoint, MicroserviceInstance instance, Object address); String getEndpoint(); MicroserviceInstance getMicroserviceInstance(); Transport getTransport(); Object getAddress(); @Override String toString(); }### Answer:
@Test public void testEndpoint(@Mocked Transport transport) { new Expectations() { { transport.parseAddress("rest: result = "rest: } }; Endpoint endpoint = new Endpoint(transport, "rest: Assert.assertEquals(endpoint.getAddress(), "rest: Assert.assertEquals(endpoint.getEndpoint(), "rest: Assert.assertEquals(endpoint.getTransport(), transport); Assert.assertEquals(endpoint.toString(), "rest: }
|
### Question:
BraveTraceIdGenerator implements TraceIdGenerator { @Override public String generate() { return Long.toHexString(Platform.get().nextTraceIdHigh()); } @Override String getTraceIdKeyName(); @Override String generate(); }### Answer:
@Test public void generateStringId() { TraceIdGenerator traceIdGenerator = new BraveTraceIdGenerator(); assertNotEquals(traceIdGenerator.generate(), traceIdGenerator.generate()); String traceId = traceIdGenerator.generate(); try { Long.parseLong(traceId, 16); } catch (NumberFormatException e) { fail("wrong traceId format: " + traceId); } }
|
### Question:
Invocation extends SwaggerInvocation { public void onStart(long start) { invocationStageTrace.start(start); initTraceId(); EventManager.post(new InvocationStartEvent(this)); } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void onStart() { mockNonaTime(); Holder<Invocation> result = new Holder<>(); Object subscriber = new Object() { @Subscribe public void onStart(InvocationStartEvent event) { result.value = event.getInvocation(); } }; EventManager.register(subscriber); Invocation invocation = new Invocation(endpoint, operationMeta, arguments); invocation.onStart(nanoTime); Assert.assertSame(invocation, result.value); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getStart()); EventManager.unregister(subscriber); }
|
### Question:
Invocation extends SwaggerInvocation { public void onFinish(Response response) { if (finished) { return; } invocationStageTrace.finish(); EventManager.post(new InvocationFinishEvent(this, response)); finished = true; } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void onFinish() { mockNonaTime(); Holder<InvocationFinishEvent> result = new Holder<>(); Object subscriber = new Object() { @Subscribe public void onStart(InvocationFinishEvent event) { result.value = event; } }; EventManager.register(subscriber); Invocation invocation = new Invocation(endpoint, operationMeta, arguments); Assert.assertFalse(invocation.isFinished()); Response response = Response.succResp(null); invocation.onFinish(response); Assert.assertEquals(nanoTime, result.value.getNanoCurrent()); Assert.assertSame(invocation, result.value.getInvocation()); Assert.assertSame(response, result.value.getResponse()); Assert.assertTrue(invocation.isFinished()); InvocationFinishEvent oldEvent = result.value; invocation.onFinish(null); Assert.assertSame(oldEvent, result.value); EventManager.unregister(subscriber); }
|
### Question:
Invocation extends SwaggerInvocation { public boolean isConsumer() { return InvocationType.CONSUMER.equals(invocationType); } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void isConsumer_yes() { Invocation invocation = new Invocation(endpoint, operationMeta, arguments); Assert.assertFalse(invocation.isConsumer()); }
@Test public void isConsumer_no(@Mocked ReferenceConfig referenceConfig) { Invocation invocation = new Invocation(referenceConfig, operationMeta, invocationRuntimeType, arguments); Assert.assertTrue(invocation.isConsumer()); }
|
### Question:
Invocation extends SwaggerInvocation { public Map<String, Object> getHandlerContext() { return handlerContext; } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void localContext(@Mocked ReferenceConfig referenceConfig) { Invocation invocation = new Invocation(referenceConfig, operationMeta, invocationRuntimeType, arguments); invocation.addLocalContext("k", 1); Assert.assertSame(invocation.getHandlerContext(), invocation.getLocalContext()); Assert.assertEquals(1, (int) invocation.getLocalContext("k")); }
|
### Question:
Invocation extends SwaggerInvocation { static Collection<TraceIdGenerator> loadTraceIdGenerators() { return SPIServiceUtils.getPriorityHighestServices(TraceIdGenerator::getName, TraceIdGenerator.class); } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void traceIdGeneratorInit(@Mocked TraceIdGenerator gen1, @Mocked TraceIdGenerator gen2, @Mocked TraceIdGenerator gen3, @Mocked TraceIdGenerator gen4) { new Expectations(SPIServiceUtils.class) { { gen1.getName(); result = "zipkin"; gen3.getName(); result = "apm"; gen2.getName(); result = "zipkin"; gen4.getName(); result = "apm"; SPIServiceUtils.getOrLoadSortedService(TraceIdGenerator.class); result = Arrays.asList(gen1, gen3, gen2, gen4); } }; Assert.assertThat(Invocation.loadTraceIdGenerators(), Matchers.contains(gen1, gen3)); }
|
### Question:
Invocation extends SwaggerInvocation { @Override public void onBusinessMethodStart() { invocationStageTrace.startBusinessMethod(); EventManager.post(new InvocationBusinessMethodStartEvent(this)); } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void onBusinessMethodStart() { Object listener = new Object() { @Subscribe public void onBusinessMethodStart(InvocationBusinessMethodStartEvent event) { invocationBaseEvent = event; } }; EventManager.getEventBus().register(listener); Invocation invocation = new Invocation(endpoint, operationMeta, arguments); mockNonaTime(); invocation.onBusinessMethodStart(); EventManager.getEventBus().unregister(listener); Assert.assertSame(invocation, invocationBaseEvent.getInvocation()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartBusinessMethod()); }
|
### Question:
Invocation extends SwaggerInvocation { @Override public void onBusinessMethodFinish() { EventManager.post(new InvocationBusinessMethodFinishEvent(this)); } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void onBusinessMethodFinish() { Object listener = new Object() { @Subscribe public void onBusinessMethodStart(InvocationBusinessMethodFinishEvent event) { invocationBaseEvent = event; } }; EventManager.getEventBus().register(listener); Invocation invocation = new Invocation(endpoint, operationMeta, arguments); invocation.onBusinessMethodFinish(); EventManager.getEventBus().unregister(listener); Assert.assertSame(invocation, invocationBaseEvent.getInvocation()); }
|
### Question:
Invocation extends SwaggerInvocation { @Override public void onBusinessFinish() { invocationStageTrace.finishBusiness(); } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void onBusinessFinish() { Invocation invocation = new Invocation(endpoint, operationMeta, arguments); mockNonaTime(); invocation.onBusinessFinish(); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishBusiness()); }
|
### Question:
Invocation extends SwaggerInvocation { public boolean isThirdPartyInvocation() { return referenceConfig.is3rdPartyService(); } Invocation(); Invocation(ReferenceConfig referenceConfig, OperationMeta operationMeta,
InvocationRuntimeType invocationRuntimeType,
Map<String, Object> swaggerArguments); Invocation(Endpoint endpoint, OperationMeta operationMeta, Map<String, Object> swaggerArguments); long getInvocationId(); TraceIdLogger getTraceIdLogger(); HttpServletRequestEx getRequestEx(); InvocationStageTrace getInvocationStageTrace(); String getTraceId(); String getTraceId(String traceIdName); @Deprecated long getStartTime(); @Deprecated long getStartExecutionTime(); Transport getTransport(); List<Handler> getHandlerChain(); Executor getResponseExecutor(); void setResponseExecutor(Executor responseExecutor); SchemaMeta getSchemaMeta(); OperationMeta getOperationMeta(); Map<String, Object> getInvocationArguments(); Map<String, Object> getSwaggerArguments(); Object getInvocationArgument(String name); Object getSwaggerArgument(String name); void setInvocationArguments(Map<String, Object> invocationArguments); void setSwaggerArguments(Map<String, Object> swaggerArguments); Object[] toProducerArguments(); void clearProducerArguments(); Endpoint getEndpoint(); void setEndpoint(Endpoint endpoint); Map<String, Object> getHandlerContext(); int getHandlerIndex(); void setHandlerIndex(int handlerIndex); void next(AsyncResponse asyncResp); String getSchemaId(); String getOperationName(); String getConfigTransportName(); String getRealTransportName(); String getMicroserviceName(); String getAppId(); MicroserviceMeta getMicroserviceMeta(); String getMicroserviceVersionRule(); InvocationRuntimeType getInvocationRuntimeType(); JavaType findResponseType(int statusCode); void setSuccessResponseType(JavaType javaType); @Override String getInvocationQualifiedName(); String getMicroserviceQualifiedName(); void onStart(long start); void onStart(HttpServletRequestEx requestEx, long start); void onExecuteStart(); void onExecuteFinish(); @Override void onBusinessMethodStart(); @Override void onBusinessMethodFinish(); void onEncodeResponseStart(Response response); @Override void onBusinessFinish(); void onFinish(Response response); boolean isFinished(); boolean isSync(); void setSync(boolean sync); boolean isConsumer(); boolean isEdge(); void setEdge(boolean edge); boolean isThirdPartyInvocation(); }### Answer:
@Test public void isThirdPartyInvocation(@Mocked ReferenceConfig referenceConfig) { Invocation invocation = new Invocation(referenceConfig, operationMeta, invocationRuntimeType, arguments); Assert.assertFalse(invocation.isThirdPartyInvocation()); new Expectations() { { referenceConfig.is3rdPartyService(); result = true; } }; Assert.assertTrue(invocation.isThirdPartyInvocation()); }
|
### Question:
TransportClientHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { Transport transport = invocation.getTransport(); log.debug( "Sending request {} to {}", invocation.getMicroserviceQualifiedName(), invocation.getEndpoint().getEndpoint()); transport.send(invocation, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); static final TransportClientHandler INSTANCE; }### Answer:
@Test public void test() throws Exception { when(invocation.getTransport()).thenReturn(transport); when(invocation.getEndpoint()).thenReturn(endpoint); transportClientHandler.handle(invocation, asyncResp); verify(transport).send(invocation, asyncResp); }
|
### Question:
ProducerOperationHandler implements Handler { protected Response processException(SwaggerInvocation invocation, Throwable e) { if (e instanceof InvocationTargetException) { e = ((InvocationTargetException) e).getTargetException(); } return ExceptionFactory.convertExceptionToResponse(invocation, e); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); void completableFutureInvoke(Invocation invocation, SwaggerProducerOperation producerOperation,
AsyncResponse asyncResp); @SuppressWarnings("unchecked") void doCompletableFutureInvoke(Invocation invocation, SwaggerProducerOperation producerOperation,
AsyncResponse asyncResp); void syncInvoke(Invocation invocation, SwaggerProducerOperation producerOperation, AsyncResponse asyncResp); Response doInvoke(Invocation invocation, SwaggerProducerOperation producerOperation); static final ProducerOperationHandler INSTANCE; }### Answer:
@Test public void processException_normal(@Mocked SwaggerInvocation invocation) { Error error = new Error("abc"); Response response = handler.processException(invocation, error); Assert.assertSame(Status.OK, response.getStatus()); Assert.assertEquals("response from error: abc", response.getResult()); }
@Test public void processException_InvocationTargetException(@Mocked SwaggerInvocation invocation) { Error error = new Error("abc"); InvocationTargetException targetException = new InvocationTargetException(error); Response response = handler.processException(invocation, error); Assert.assertSame(Status.OK, response.getStatus()); Assert.assertEquals("response from error: abc", response.getResult()); }
|
### Question:
SimpleLoadBalanceHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (invocation.getEndpoint() != null) { invocation.next(asyncResp); return; } DiscoveryContext context = new DiscoveryContext(); context.setInputParameters(invocation); VersionedCache endpointsVersionedCache = discoveryTree.discovery(context, invocation.getAppId(), invocation.getMicroserviceName(), invocation.getMicroserviceVersionRule()); if (endpointsVersionedCache.isEmpty()) { asyncResp.consumerFail(ExceptionUtils.lbAddressNotFound(invocation.getMicroserviceName(), invocation.getMicroserviceVersionRule(), endpointsVersionedCache.name())); return; } List<Endpoint> endpoints = endpointsVersionedCache.data(); AtomicInteger index = indexMap.computeIfAbsent(endpointsVersionedCache.name(), name -> { LOGGER.info("Create loadBalancer for {}.", name); return new AtomicInteger(); }); LOGGER.debug("invocation {} use discoveryGroup {}.", invocation.getMicroserviceQualifiedName(), endpointsVersionedCache.name()); int idx = Math.abs(index.getAndIncrement()); idx = idx % endpoints.size(); Endpoint endpoint = endpoints.get(idx); invocation.setEndpoint(endpoint); invocation.next(asyncResp); } SimpleLoadBalanceHandler(); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }### Answer:
@Test public void handle_emptyEndPoint() throws Exception { handler.handle(invocation, ar); Throwable result = response.getResult(); Assert.assertEquals( "InvocationException: code=490;msg=CommonExceptionData [message=Unexpected consumer error, please check logs for details]", result.getMessage()); Assert.assertEquals("No available address found. microserviceName=null, version=null, discoveryGroupName=parent/", result.getCause().getMessage()); }
@Test public void handle(@Mocked Transport transport) throws Exception { MicroserviceInstance instance = new MicroserviceInstance(); instance.setInstanceId("id"); instance.getEndpoints().add("rest: instance.getEndpoints().add("highway: instanceVersionedCache.data(Collections.singletonMap("id", instance)).autoCacheVersion().name("vr"); new Expectations(scbEngine.getTransportManager()) { { SCBEngine.getInstance().getTransportManager().findTransport(anyString); result = transport; invocation.getConfigTransportName(); result = ""; } }; handler.handle(invocation, ar); AtomicInteger idx = indexMap.values().iterator().next(); Assert.assertEquals(1, idx.get()); handler.handle(invocation, ar); Assert.assertEquals(2, idx.get()); }
|
### Question:
ZeroConfigClient { public MicroserviceInstances findServiceInstances(String appId, String providerServiceName, String strVersionRule) { LOGGER.info( "Find service instance for App ID: {}, Provider ServiceName: {}, versionRule: {} in Zero-Config mode", appId, providerServiceName, strVersionRule); MicroserviceInstances resultMicroserviceInstances = new MicroserviceInstances(); FindInstancesResponse response = new FindInstancesResponse(); List<MicroserviceInstance> resultInstanceList = new ArrayList<>(); List<ServerMicroserviceInstance> tempServerInstanceList = this.zeroConfigRegistryService. findServiceInstances(appId, providerServiceName); VersionRule versionRule = VersionRuleUtils.getOrCreate(strVersionRule); ServerMicroserviceInstance latestVersionInstance = findLatestVersionInstance( tempServerInstanceList, versionRule); if (latestVersionInstance != null) { Version latestVersion = VersionUtils.getOrCreate(latestVersionInstance.getVersion()); for (ServerMicroserviceInstance serverInstance : tempServerInstanceList) { Version version = VersionUtils.getOrCreate(serverInstance.getVersion()); if (!versionRule.isMatch(version, latestVersion)) { continue; } resultInstanceList.add(ClientUtil.convertToClientMicroserviceInstance(serverInstance)); } } response.setInstances(resultInstanceList); resultMicroserviceInstances.setInstancesResponse(response); return resultMicroserviceInstances; } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked(
ZeroConfigRegistryService zeroConfigRegistryService,
MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName,
String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice(
Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance(
MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer:
@Test public void test_findServiceInstances_forNonExistInstance_shouldReturnEmptyResult() { List<ServerMicroserviceInstance> serverMicroserviceInstancesList = new ArrayList<>(); when(zeroConfigRegistryService.findServiceInstances(selfServiceId, selfInstanceId)) .thenReturn(serverMicroserviceInstancesList); MicroserviceInstances returnedResult = target .findServiceInstances(appId, serviceName, strVersionRule); Assert.assertEquals(0, returnedResult.getInstancesResponse().getInstances().size()); }
@Test public void test_findServiceInstances_forExistInstance_shouldReturnInstances() { List<ServerMicroserviceInstance> serverMicroserviceInstancesList = new ArrayList<>(); serverMicroserviceInstancesList.add(prepareServerServiceInstance(true)); when(zeroConfigRegistryService.findServiceInstances(appId, serviceName)) .thenReturn(serverMicroserviceInstancesList); MicroserviceInstances returnedResult = target .findServiceInstances(appId, serviceName, strVersionRule); List<MicroserviceInstance> returnedInstanceList = returnedResult.getInstancesResponse() .getInstances(); Assert.assertEquals(1, returnedInstanceList.size()); Assert.assertEquals(selfInstanceId, returnedInstanceList.get(0).getInstanceId()); }
|
### Question:
CseApplicationListener implements ApplicationListener<ApplicationEvent>, Ordered, ApplicationContextAware { @Override public void onApplicationEvent(ApplicationEvent event) { if (initEventClass.isInstance(event)) { if (applicationContext instanceof AbstractApplicationContext) { ((AbstractApplicationContext) applicationContext).registerShutdownHook(); } SCBEngine scbEngine = SCBEngine.getInstance(); scbEngine.setApplicationContext(applicationContext); scbEngine.setFilterChainsManager(applicationContext.getBean(FilterChainsManager.class)); scbEngine.getConsumerProviderManager().getConsumerProviderList() .addAll(applicationContext.getBeansOfType(ConsumerProvider.class).values()); scbEngine.getProducerProviderManager().getProducerProviderList() .addAll(applicationContext.getBeansOfType(ProducerProvider.class).values()); scbEngine.addBootListeners(applicationContext.getBeansOfType(BootListener.class).values()); scbEngine.run(); } else if (event instanceof ContextClosedEvent) { if (SCBEngine.getInstance() != null) { SCBEngine.getInstance().destroy(); } } } @Override void setApplicationContext(ApplicationContext applicationContext); void setInitEventClass(Class<?> initEventClass); @Override int getOrder(); @Override void onApplicationEvent(ApplicationEvent event); }### Answer:
@Test public void onApplicationEvent_close(@Mocked ContextClosedEvent contextClosedEvent) { SCBEngine scbEngine = SCBBootstrap.createSCBEngineForTest(); scbEngine.setStatus(SCBStatus.UP); CseApplicationListener listener = new CseApplicationListener(); listener.onApplicationEvent(contextClosedEvent); Assert.assertEquals(SCBStatus.DOWN, scbEngine.getStatus()); scbEngine.destroy(); }
|
### Question:
InvocationFinishEvent extends InvocationWithResponseEvent { public long getNanoCurrent() { return nanoCurrent; } InvocationFinishEvent(Invocation invocation, Response response); long getNanoCurrent(); }### Answer:
@Test public void construct(@Mocked Invocation invocation, @Mocked Response response) { InvocationStageTrace stageTrace = new InvocationStageTrace(invocation); long time = 123; new MockUp<System>() { @Mock long nanoTime() { return time; } }; new Expectations() { { invocation.getInvocationStageTrace(); result = stageTrace; } }; stageTrace.finish(); event = new InvocationFinishEvent(invocation, response); Assert.assertEquals(time, event.getNanoCurrent()); Assert.assertSame(invocation, event.getInvocation()); Assert.assertSame(response, event.getResponse()); }
|
### Question:
MultipartFilePropertyCreator implements PropertyCreator { @Override public Property createProperty() { return new FileProperty(); } @Override Property createProperty(); @Override Class<?>[] classes(); }### Answer:
@Test public void createProperty() { Property property = multipartFilePropertyCreator.createProperty(); Assert.assertThat(property, Matchers.instanceOf(FileProperty.class)); }
|
### Question:
MultipartFilePropertyCreator implements PropertyCreator { @Override public Class<?>[] classes() { return classes; } @Override Property createProperty(); @Override Class<?>[] classes(); }### Answer:
@Test public void classes() { Class<?>[] classes = multipartFilePropertyCreator.classes(); Assert.assertThat(classes, Matchers.arrayContaining(MultipartFile.class)); }
|
### Question:
RequestPartAnnotationProcessor extends
AbstractSpringmvcSerializableParameterProcessor<FormParameter, RequestPart> { @Override public Type getProcessType() { return RequestPart.class; } @Override Type getProcessType(); @Override String getParameterName(RequestPart annotation); @Override HttpParameterType getHttpParameterType(RequestPart parameterAnnotation); }### Answer:
@Test public void getProcessType() { Assert.assertEquals(requestPartAnnotationProcessor.getProcessType(), RequestPart.class); }
|
### Question:
RequestPartAnnotationProcessor extends
AbstractSpringmvcSerializableParameterProcessor<FormParameter, RequestPart> { @Override public String getParameterName(RequestPart annotation) { String value = annotation.value(); if (value.isEmpty()) { value = annotation.name(); } return value; } @Override Type getProcessType(); @Override String getParameterName(RequestPart annotation); @Override HttpParameterType getHttpParameterType(RequestPart parameterAnnotation); }### Answer:
@Test public void getParameterName_fromValue() { Parameter[] parameters = producerMethod.getParameters(); Parameter stringParam = parameters[0]; RequestPart stringParamAnnotation = stringParam.getAnnotation(RequestPart.class); Assert.assertThat(requestPartAnnotationProcessor.getParameterName(stringParamAnnotation), Matchers.is("stringParam")); }
@Test public void getParameterName_fromName() { Parameter[] parameters = producerMethod.getParameters(); Parameter intParam = parameters[1]; RequestPart intParamAnnotation = intParam.getAnnotation(RequestPart.class); Assert.assertThat(requestPartAnnotationProcessor.getParameterName(intParamAnnotation), Matchers.is("intParam")); }
|
### Question:
RequestPartAnnotationProcessor extends
AbstractSpringmvcSerializableParameterProcessor<FormParameter, RequestPart> { @Override public HttpParameterType getHttpParameterType(RequestPart parameterAnnotation) { return HttpParameterType.FORM; } @Override Type getProcessType(); @Override String getParameterName(RequestPart annotation); @Override HttpParameterType getHttpParameterType(RequestPart parameterAnnotation); }### Answer:
@Test public void getHttpParameterType() { Assert.assertThat(requestPartAnnotationProcessor.getHttpParameterType(null), Matchers.is(HttpParameterType.FORM)); }
|
### Question:
MethodUtils { public static List<Method> findSwaggerMethods(Class<?> cls) { Method[] methods = cls.getMethods(); List<Method> result = new ArrayList<>(methods.length); for (Method m : methods) { if (!isSkipMethod(cls, m)) { result.add(m); } } result.sort(Comparator.comparing(MethodUtils::findSwaggerMethodName)); return result; } static List<Method> findSwaggerMethods(Class<?> cls); static Map<String, Method> findSwaggerMethodsMapOfOperationId(Class<?> cls); static boolean isSkipMethod(Class<?> cls, Method method); static String findSwaggerMethodName(Method method); }### Answer:
@Test public void testGetClassMethods() throws Exception { List<Method> methods = MethodUtils.findSwaggerMethods(Hello2Endpoint.class); Assert.assertEquals(3, methods.size()); Assert.assertEquals(Hello2Endpoint.class, methods.get(0).getDeclaringClass()); Assert.assertEquals(Hello2Endpoint.class, methods.get(1).getDeclaringClass()); Assert.assertEquals(Hello2Endpoint.class, methods.get(2).getDeclaringClass()); methods = MethodUtils.findSwaggerMethods(HelloEndpoint.class); Assert.assertEquals(2, methods.size()); Assert.assertEquals(HelloEndpoint.class, methods.get(0).getDeclaringClass()); Assert.assertEquals(AbstractBaseClass.class, methods.get(1).getDeclaringClass()); methods = MethodUtils.findSwaggerMethods(ServiceInterface.class); Assert.assertEquals(3, methods.size()); Assert.assertEquals(BaseInterface.class, methods.get(0).getDeclaringClass()); Assert.assertEquals(BaseInterface.class, methods.get(1).getDeclaringClass()); Assert.assertEquals(ServiceInterface.class, methods.get(2).getDeclaringClass()); }
|
### Question:
ApiOperationProcessor implements MethodAnnotationProcessor<ApiOperation> { private void convertTags(String[] tags, Operation operation) { if (tags == null || tags.length == 0) { return; } for (String tag : tags) { if (StringUtils.isEmpty(tag)) { continue; } operation.addTag(tag); } } Type getProcessType(); @Override void process(SwaggerGenerator swaggerGenerator,
OperationGenerator operationGenerator, ApiOperation apiOperationAnnotation); }### Answer:
@Test public void testConvertTags() { SwaggerOperation swaggerOperation = swaggerOperations.findOperation("function"); assertThat(swaggerOperation.getOperation().getTags(), containsInAnyOrder("tag1", "tag2")); }
|
### Question:
SwaggerDefinitionProcessor implements ClassAnnotationProcessor<SwaggerDefinition> { @Override public void process(SwaggerGenerator swaggerGenerator, SwaggerDefinition definitionAnnotation) { Swagger swagger = swaggerGenerator.getSwagger(); if (StringUtils.isNotEmpty(definitionAnnotation.basePath())) { swaggerGenerator.setBasePath(definitionAnnotation.basePath()); } if (StringUtils.isNotEmpty(definitionAnnotation.host())) { swagger.setHost(definitionAnnotation.host()); } SwaggerUtils.setConsumes(swagger, definitionAnnotation.consumes()); SwaggerUtils.setProduces(swagger, definitionAnnotation.produces()); convertSchemes(definitionAnnotation, swagger); convertTags(definitionAnnotation, swagger); convertInfo(definitionAnnotation.info(), swagger); swagger.setExternalDocs(convertExternalDocs(definitionAnnotation.externalDocs())); } @Override Type getProcessType(); @Override void process(SwaggerGenerator swaggerGenerator, SwaggerDefinition definitionAnnotation); }### Answer:
@Test public void testProcess() { Swagger swagger = SwaggerGenerator.generate(SwaggerTestTarget.class); assertEquals(1, swagger.getTags().size()); io.swagger.models.Tag tag = swagger.getTags().get(0); assertEquals("testTag", tag.getName()); assertEquals("desc", tag.getDescription()); assertEquals("testValue", tag.getExternalDocs().getDescription()); assertEquals("testUrl", tag.getExternalDocs().getUrl()); assertEquals("127.0.0.1", swagger.getHost()); assertThat(swagger.getSchemes(), contains(io.swagger.models.Scheme.HTTP, io.swagger.models.Scheme.HTTPS)); io.swagger.models.Info info = swagger.getInfo(); assertEquals("title", info.getTitle()); assertEquals("version", info.getVersion()); assertEquals("desc", info.getDescription()); assertEquals("contactName", info.getContact().getName()); assertEquals("licenseName", info.getLicense().getName()); assertThat(swagger.getConsumes(), Matchers.contains(MediaType.APPLICATION_JSON, MediaType.TEXT_PLAIN)); assertThat(swagger.getProduces(), Matchers.contains(MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML)); }
|
### Question:
ApiProcessor implements ClassAnnotationProcessor<Api> { @Override public void process(SwaggerGenerator swaggerGenerator, Api api) { setTags(swaggerGenerator, api); SwaggerUtils.setCommaConsumes(swaggerGenerator.getSwagger(), api.consumes()); SwaggerUtils.setCommaProduces(swaggerGenerator.getSwagger(), api.produces()); } @Override Type getProcessType(); @Override void process(SwaggerGenerator swaggerGenerator, Api api); }### Answer:
@Test public void process() { SwaggerOperations swaggerOperations = SwaggerOperations.generate(SwaggerTestTarget.class); SwaggerOperation swaggerOperation = swaggerOperations.findOperation("op"); assertThat(swaggerOperation.getOperation().getTags(), contains("tag1", "tag2")); assertThat(swaggerOperation.getSwagger().getConsumes(), Matchers.contains(MediaType.APPLICATION_JSON)); assertThat(swaggerOperation.getSwagger().getProduces(), Matchers.contains(MediaType.APPLICATION_JSON)); }
|
### Question:
PartPropertyCreator implements PropertyCreator { @Override public Class<?>[] classes() { return classes; } @Override Property createProperty(); @Override Class<?>[] classes(); }### Answer:
@SuppressWarnings("unchecked") @Test public void classes() { Assert.assertThat(creator.classes(), Matchers.arrayContaining(Part.class)); }
|
### Question:
PartPropertyCreator implements PropertyCreator { @Override public Property createProperty() { return new FileProperty(); } @Override Property createProperty(); @Override Class<?>[] classes(); }### Answer:
@Test public void createProperty() { Assert.assertThat(creator.createProperty(), Matchers.instanceOf(FileProperty.class)); }
|
### Question:
ModelResolverExt extends ModelResolver { @VisibleForTesting protected void setType(JavaType type, Map<String, Object> vendorExtensions) { if (SwaggerGeneratorFeature.isLocalExtJavaClassInVendor()) { vendorExtensions.put(SwaggerConst.EXT_JAVA_CLASS, type.toCanonical()); } } ModelResolverExt(); @Override Model resolve(JavaType type, ModelConverterContext context, Iterator<ModelConverter> next); @Override Property resolveProperty(JavaType propType, ModelConverterContext context, Annotation[] annotations,
Iterator<ModelConverter> next); }### Answer:
@Test public void setType() { JavaType type = TypeFactory.defaultInstance().constructCollectionType(List.class, String.class); resolver.setType(type, vendorExtensions); Assert.assertEquals("java.util.List<java.lang.String>", vendorExtensions.get(SwaggerConst.EXT_JAVA_CLASS)); }
|
### Question:
JsonPropertyIntrospector extends SwaggerAnnotationIntrospector { @SuppressWarnings("deprecation") @Override public String findEnumValue(Enum<?> value) { try { JsonProperty annotation = value.getClass().getField(value.name()).getAnnotation(JsonProperty.class); if (null == annotation || StringUtils.isEmpty(annotation.value())) { return super.findEnumValue(value); } return annotation.value(); } catch (NoSuchFieldException e) { return super.findEnumValue(value); } } @SuppressWarnings("deprecation") @Override String findEnumValue(Enum<?> value); }### Answer:
@Test public void findEnumValue() { JsonPropertyIntrospector introspector = new JsonPropertyIntrospector(); assertEquals("AB", introspector.findEnumValue(TestEnum.AB)); assertEquals("C-D", introspector.findEnumValue(TestEnum.C_D)); assertEquals("E.F", introspector.findEnumValue(TestEnum.E_F)); assertEquals("HI", introspector.findEnumValue(TestEnum.HI)); }
|
### Question:
SwaggerUtils { public static String swaggerToString(Swagger swagger) { try { return Yaml.mapper().writeValueAsString(swagger); } catch (Throwable e) { throw new ServiceCombException("Convert swagger to string failed, ", e); } } private SwaggerUtils(); static String swaggerToString(Swagger swagger); static Swagger parseSwagger(URL url); static Swagger parseAndValidateSwagger(URL url); static Swagger parseSwagger(String swaggerContent); static Swagger parseAndValidateSwagger(String swaggerContent); static void validateSwagger(Swagger swagger); static void correctResponses(Operation operation); static void correctResponses(Swagger swagger); static Map<String, Property> getBodyProperties(Swagger swagger, Parameter parameter); static void addDefinitions(Swagger swagger, Type paramType); static void setParameterType(Swagger swagger, JavaType type, AbstractSerializableParameter<?> parameter); static boolean isBean(Model model); static boolean isBean(Property property); static boolean isComplexProperty(Property property); static ModelImpl getModelImpl(Swagger swagger, BodyParameter bodyParameter); static void setCommaConsumes(Swagger swagger, String commaConsumes); static void setCommaConsumes(Operation operation, String commaConsumes); static void setConsumes(Operation operation, String... consumes); static void setConsumes(Swagger swagger, String... consumes); static List<String> convertConsumesOrProduces(String... consumesOrProduces); static void setCommaProduces(Swagger swagger, String commaProduces); static void setCommaProduces(Operation operation, String commaProduces); static void setProduces(Operation operation, String... produces); static void setProduces(Swagger swagger, String... produces); static boolean hasAnnotation(Class<?> cls, Class<? extends Annotation> annotation); static boolean isRawJsonType(Parameter param); static Class<?> getInterface(Swagger swagger); static String getClassName(Map<String, Object> vendorExtensions); static String getInterfaceName(Map<String, Object> vendorExtensions); @SuppressWarnings("unchecked") static T getVendorExtension(Map<String, Object> vendorExtensions, String key); static boolean isBean(Type type); static boolean isFileParameter(Parameter parameter); }### Answer:
@Test public void swaggerToStringException(@Mocked Swagger swagger) { new Expectations() { { swagger.getBasePath(); result = new RuntimeExceptionWithoutStackTrace(); } }; expectedException.expect(ServiceCombException.class); expectedException.expectMessage("Convert swagger to string failed, "); SwaggerUtils.swaggerToString(swagger); }
|
### Question:
SwaggerUtils { public static Swagger parseSwagger(URL url) { try { String swaggerContent = IOUtils.toString(url, StandardCharsets.UTF_8); return internalParseSwagger(swaggerContent); } catch (Throwable e) { throw new ServiceCombException("Parse swagger from url failed, url=" + url, e); } } private SwaggerUtils(); static String swaggerToString(Swagger swagger); static Swagger parseSwagger(URL url); static Swagger parseAndValidateSwagger(URL url); static Swagger parseSwagger(String swaggerContent); static Swagger parseAndValidateSwagger(String swaggerContent); static void validateSwagger(Swagger swagger); static void correctResponses(Operation operation); static void correctResponses(Swagger swagger); static Map<String, Property> getBodyProperties(Swagger swagger, Parameter parameter); static void addDefinitions(Swagger swagger, Type paramType); static void setParameterType(Swagger swagger, JavaType type, AbstractSerializableParameter<?> parameter); static boolean isBean(Model model); static boolean isBean(Property property); static boolean isComplexProperty(Property property); static ModelImpl getModelImpl(Swagger swagger, BodyParameter bodyParameter); static void setCommaConsumes(Swagger swagger, String commaConsumes); static void setCommaConsumes(Operation operation, String commaConsumes); static void setConsumes(Operation operation, String... consumes); static void setConsumes(Swagger swagger, String... consumes); static List<String> convertConsumesOrProduces(String... consumesOrProduces); static void setCommaProduces(Swagger swagger, String commaProduces); static void setCommaProduces(Operation operation, String commaProduces); static void setProduces(Operation operation, String... produces); static void setProduces(Swagger swagger, String... produces); static boolean hasAnnotation(Class<?> cls, Class<? extends Annotation> annotation); static boolean isRawJsonType(Parameter param); static Class<?> getInterface(Swagger swagger); static String getClassName(Map<String, Object> vendorExtensions); static String getInterfaceName(Map<String, Object> vendorExtensions); @SuppressWarnings("unchecked") static T getVendorExtension(Map<String, Object> vendorExtensions, String key); static boolean isBean(Type type); static boolean isFileParameter(Parameter parameter); }### Answer:
@Test public void parseSwaggerUrlNormal(@Mocked URL url) throws IOException { String content = "swagger: \"2.0\""; new Expectations(IOUtils.class) { { IOUtils.toString(url, StandardCharsets.UTF_8); result = content; } }; Swagger swagger = Yaml.mapper().readValue(content, Swagger.class); Swagger result = SwaggerUtils.parseSwagger(url); Assert.assertEquals(swagger, result); }
@Test public void parseSwaggerUrlException(@Mocked URL url) throws IOException { new Expectations(IOUtils.class) { { IOUtils.toString(url, StandardCharsets.UTF_8); result = new RuntimeExceptionWithoutStackTrace("failed"); } }; expectedException.expect(ServiceCombException.class); expectedException.expectMessage("Parse swagger from url failed, "); SwaggerUtils.parseSwagger(url); }
@Test public void parseSwaggerContentException() throws IOException { expectedException.expect(ServiceCombException.class); expectedException.expectMessage("Parse swagger from content failed, "); SwaggerUtils.parseSwagger(""); }
|
### Question:
ZeroConfigRegistryService { public void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String instanceId = receivedInstance.getInstanceId(); String serviceId = receivedInstance.getServiceId(); String serviceName = receivedInstance.getServiceName(); if (serviceId == null || serviceName == null || instanceId == null) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + serviceId + "Invalid serviceName, serviceName=" + serviceName + "Invalid instanceId, instanceId=" + instanceId); } Map<String, ServerMicroserviceInstance> innerInstanceMap = ServerUtil.microserviceInstanceMap. computeIfAbsent(serviceId, id -> new ConcurrentHashMap<>()); if (innerInstanceMap.containsKey(instanceId)) { LOGGER.info("ServiceId: {}, instanceId: {} already exists", serviceId, instanceId); } else { LOGGER .info("Register a new instance for serviceId: {}, instanceId: {}, status: {}, name: {}", serviceId, instanceId, receivedInstance.getStatus(), receivedInstance.getServiceName()); innerInstanceMap.put(instanceId, receivedInstance); } } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }### Answer:
@Test(expected = IllegalArgumentException.class) public void test_registerMicroserviceInstance_whenServiceIdIsNull_shouldThrowIllegalArgumentException() { target.registerMicroserviceInstance(prepareServerServiceInstance(false, instanceId)); }
@Test public void test_registerMicroserviceInstance_whenInstanceNotExist_shouldRegisterSuccessfully() { ServerUtil.microserviceInstanceMap = prepareEmptyServiceInstanceMap(); target.registerMicroserviceInstance(prepareServerServiceInstance(true, instanceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.containsKey(serviceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.get(serviceId).containsKey(instanceId)); }
@Test public void test_registerMicroserviceInstance_whenInstanceExist_shouldRegisterSuccessfully() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); target.registerMicroserviceInstance(prepareServerServiceInstance(true, instanceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.containsKey(serviceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.get(serviceId).containsKey(instanceId)); Assert.assertEquals(1, ServerUtil.microserviceInstanceMap.size()); }
|
### Question:
JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } @Override Object mapResponse(Response response); }### Answer:
@SuppressWarnings("unchecked") @Test public void jaxrsResponse() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("jaxrsResponse"); Response jaxrsResponse = (Response) operation.getResponseMapper().mapResponse(response); Assert.assertEquals(result, jaxrsResponse.getEntity()); Assert.assertTrue(jaxrsResponse.getHeaders().isEmpty()); }
@Test public void jaxrsResponseWithHeaders() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("jaxrsResponse"); response.getHeaders().addHeader("h", "v1").addHeader("h", "v2").addHeader("h", (Object) null); response.getHeaders().getHeaderMap().put("h1", null); Response jaxrsResponse = (Response) operation.getResponseMapper().mapResponse(response); Assert.assertEquals(result, jaxrsResponse.getEntity()); Assert.assertEquals(1, jaxrsResponse.getHeaders().size()); Assert.assertThat(jaxrsResponse.getHeaders().get("h"), Matchers.contains("v1", "v2")); }
|
### Question:
JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } @Override Response mapResponse(StatusType status, Object response); }### Answer:
@Test public void mapResponse_withoutHeaders() { new Expectations() { { jaxrsResponse.getStatusInfo(); result = Status.OK; jaxrsResponse.getEntity(); result = "result"; } }; Response response = mapper.mapResponse(null, jaxrsResponse); Assert.assertEquals(Status.OK, response.getStatus()); Assert.assertEquals("result", response.getResult()); Assert.assertNull(response.getHeaders().getHeaderMap()); }
@Test public void mapResponse_withHeaders() { MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>(); headers.add("h", "v"); new Expectations() { { jaxrsResponse.getStatusInfo(); result = Status.OK; jaxrsResponse.getEntity(); result = "result"; jaxrsResponse.getHeaders(); result = headers; } }; Response response = mapper.mapResponse(null, jaxrsResponse); Assert.assertEquals(Status.OK, response.getStatus()); Assert.assertEquals("result", response.getResult()); Assert.assertEquals(1, response.getHeaders().getHeaderMap().size()); Assert.assertThat(response.getHeaders().getHeader("h"), Matchers.contains("v")); }
|
### Question:
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }### Answer:
@Test public void isMatch_true() { Assert.assertTrue(factory.isMatch(Response.class)); }
@Test public void isMatch_false() { Assert.assertFalse(factory.isMatch(String.class)); }
|
### Question:
ZeroConfigRegistryService { public void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance) { String unregisterServiceId = receivedInstance.getServiceId(); String unregisterInstanceId = receivedInstance.getInstanceId(); if (unregisterServiceId == null || unregisterInstanceId == null) { throw new IllegalArgumentException( "Invalid unregisterServiceId, unregisterServiceId=" + unregisterServiceId + "Invalid unregisterInstanceId, unregisterInstanceId=" + unregisterInstanceId); } ServerUtil.microserviceInstanceMap .computeIfPresent(unregisterServiceId, (serviceId, instanceIdMap) -> { instanceIdMap.computeIfPresent(unregisterInstanceId, (instanceId, instance) -> { LOGGER.info( "Successfully unregistered/remove serviceId: {}, instanceId: {} from server side", unregisterServiceId, unregisterInstanceId); return null; }); return !instanceIdMap.isEmpty() ? instanceIdMap : null; }); } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId,
String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId,
String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }### Answer:
@Test(expected = IllegalArgumentException.class) public void test_unregisterMicroserviceInstance_whenServiceIdIsNull_shouldThrowIllegalArgumentException() { target.unregisterMicroserviceInstance(prepareServerServiceInstance(false, instanceId)); }
@Test public void test_unregisterMicroserviceInstance_withServiceIdAndInstanceId_and_multipleInstance_shouldRemoveInstance() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); target.unregisterMicroserviceInstance(prepareServerServiceInstance(true, instanceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.containsKey(serviceId)); Assert.assertTrue(ServerUtil.microserviceInstanceMap.get(serviceId).containsKey(instanceId1)); Assert.assertFalse(ServerUtil.microserviceInstanceMap.get(serviceId).containsKey(instanceId)); }
@Test public void test_unregisterMicroserviceInstance_withServiceIdAndInstanceId_and_singleInstance_shouldRemoveService() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); target.unregisterMicroserviceInstance(prepareServerServiceInstance(true, instanceId)); Assert.assertFalse(ServerUtil.microserviceInstanceMap.containsKey(serviceId)); }
|
### Question:
JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { return new JaxrsProducerResponseMapper(); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }### Answer:
@Test public void createResponseMapper() { Assert.assertThat(factory.createResponseMapper(null, null), Matchers.instanceOf(JaxrsProducerResponseMapper.class)); }
|
### Question:
DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } @Override List<String> getParameterNames(Constructor<?> constructor); @Override List<String> getParameterNames(Method method); }### Answer:
@Test public void testMethod() throws NoSuchMethodException { Method method = validatorForTest.getMethod("add", int.class, int.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("a", "b")); method = validatorForTest.getMethod("sayHi", String.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("hi")); method = validatorForTest.getMethod("sayHello", ValidatorForTest.Student.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("student")); method = validatorForTest.getMethod("setTest", String.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("grade")); method = validatorForTest.getMethod("getNumber"); Assert.assertTrue(parameterNameProvider.getParameterNames(method).isEmpty()); method = validatorForTest.getMethod("setNumber", int.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("number")); }
@Test public void testConstructor() throws NoSuchMethodException { Constructor<ValidatorForTest> constructor = validatorForTest.getConstructor(String.class, int.class); Assert.assertThat(parameterNameProvider.getParameterNames(constructor), Matchers.contains("grade", "number")); constructor = validatorForTest.getConstructor(); Assert.assertTrue(parameterNameProvider.getParameterNames(constructor).isEmpty()); }
|
### Question:
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }### Answer:
@Test public void isMatch_true() { Method method = ReflectUtils.findMethod(this.getClass(), "responseEntity"); Assert.assertTrue(factory.isMatch(method.getGenericReturnType())); }
@Test public void isMatch_Parameterized_false() { Method method = ReflectUtils.findMethod(this.getClass(), "list"); Assert.assertFalse(factory.isMatch(method.getGenericReturnType())); }
@Test public void isMatch_false() { Assert.assertFalse(factory.isMatch(String.class)); }
|
### Question:
SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { Type realProducerType = ((ParameterizedType) producerType).getActualTypeArguments()[0]; ProducerResponseMapper realMapper = factorys.createResponseMapper(realProducerType); return new SpringmvcProducerResponseMapper(realMapper); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys,
Type producerType); }### Answer:
@Test public void createResponseMapper() { Method responseEntityMethod = ReflectUtils.findMethod(this.getClass(), "responseEntity"); ProducerResponseMapper mapper = factory .createResponseMapper(factorys, responseEntityMethod.getGenericReturnType()); Assert.assertThat(mapper, Matchers.instanceOf(SpringmvcProducerResponseMapper.class)); ResponseEntity<String[]> responseEntity = new ResponseEntity<>(new String[] {"a", "b"}, HttpStatus.OK); Response response = mapper.mapResponse(null, responseEntity); Assert.assertThat(response.getResult(), Matchers.arrayContaining("a", "b")); }
|
### Question:
SpringmvcConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { HttpStatus status = HttpStatus.valueOf(response.getStatusCode()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, null, status); } HttpHeaders httpHeaders = new HttpHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { httpHeaders.add(entry.getKey(), String.valueOf(value)); } } } Object realResult = realMapper.mapResponse(response); return new ResponseEntity<>(realResult, httpHeaders, status); } SpringmvcConsumerResponseMapper(ConsumerResponseMapper realMapper); @Override Object mapResponse(Response response); }### Answer:
@Test public void responseEntity() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("responseEntity"); @SuppressWarnings("unchecked") ResponseEntity<String> responseEntity = (ResponseEntity<String>) operation.getResponseMapper() .mapResponse(response); Assert.assertEquals(result, responseEntity.getBody()); Assert.assertTrue(responseEntity.getHeaders().isEmpty()); }
@Test public void responseEntityWithHeader() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("responseEntity"); response.getHeaders().addHeader("h", "v"); @SuppressWarnings("unchecked") ResponseEntity<String> responseEntity = (ResponseEntity<String>) operation.getResponseMapper() .mapResponse(response); Assert.assertEquals(result, responseEntity.getBody()); Assert.assertEquals(1, responseEntity.getHeaders().size()); Assert.assertThat(responseEntity.getHeaders().get("h"), Matchers.contains("v")); }
@Test public void asyncResponseEntity() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("asyncResponseEntity"); @SuppressWarnings("unchecked") ResponseEntity<String> responseEntity = (ResponseEntity<String>) operation.getResponseMapper() .mapResponse(response); Assert.assertEquals(result, responseEntity.getBody()); Assert.assertTrue(responseEntity.getHeaders().isEmpty()); }
@Test public void asyncResponseEntityWithHeader() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("asyncResponseEntity"); response.getHeaders().addHeader("h", "v1").addHeader("h", "v2"); response.getHeaders().getHeaderMap().put("h1", null); @SuppressWarnings("unchecked") ResponseEntity<String> responseEntity = (ResponseEntity<String>) operation.getResponseMapper() .mapResponse(response); Assert.assertEquals(result, responseEntity.getBody()); Assert.assertEquals(1, responseEntity.getHeaders().size()); Assert.assertThat(responseEntity.getHeaders().get("h"), Matchers.contains("v1", "v2")); }
|
### Question:
SpringmvcProducerResponseMapper implements ProducerResponseMapper { @SuppressWarnings("unchecked") @Override public Response mapResponse(StatusType status, Object response) { ResponseEntity<Object> springmvcResponse = (ResponseEntity<Object>) response; StatusType responseStatus = new HttpStatus(springmvcResponse.getStatusCode().value(), springmvcResponse.getStatusCode().getReasonPhrase()); Response cseResponse = null; if (HttpStatus.isSuccess(responseStatus)) { cseResponse = realMapper.mapResponse(responseStatus, springmvcResponse.getBody()); } else { cseResponse = Response.status(responseStatus).entity(springmvcResponse.getBody()); } HttpHeaders headers = springmvcResponse.getHeaders(); Headers cseHeaders = cseResponse.getHeaders(); for (Entry<String, List<String>> entry : headers.entrySet()) { if (entry.getValue() == null || entry.getValue().isEmpty()) { continue; } for (String value : entry.getValue()) { cseHeaders.addHeader(entry.getKey(), value); } } return cseResponse; } SpringmvcProducerResponseMapper(ProducerResponseMapper realMapper); @SuppressWarnings("unchecked") @Override Response mapResponse(StatusType status, Object response); }### Answer:
@SuppressWarnings("unchecked") @Test public void mapResponse_withoutHeader_sucess() { ResponseEntity<String[]> responseEntity = new ResponseEntity<>(arrResult, org.springframework.http.HttpStatus.OK); Response response = mapper.mapResponse(null, responseEntity); Assert.assertThat((List<String>) response.getResult(), Matchers.contains("a", "b")); Assert.assertEquals(Status.OK, response.getStatus()); }
@Test public void mapResponse_withoutHeader_fail() { ResponseEntity<String[]> responseEntity = new ResponseEntity<>(arrResult, org.springframework.http.HttpStatus.BAD_REQUEST); Response response = mapper.mapResponse(null, responseEntity); Assert.assertSame(arrResult, response.getResult()); Assert.assertEquals(Status.BAD_REQUEST.getStatusCode(), response.getStatus().getStatusCode()); }
@Test public void mapResponse_withHeader() { HttpHeaders headers = new HttpHeaders(); headers.add("h", "v"); ResponseEntity<String[]> responseEntity = new ResponseEntity<>(arrResult, headers, org.springframework.http.HttpStatus.OK); Response response = mapper.mapResponse(null, responseEntity); List<Object> hv = response.getHeaders().getHeader("h"); Assert.assertThat(hv, Matchers.contains("v")); }
|
### Question:
PartToMultipartFile implements MultipartFile { @Override public String getName() { return part.getName(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer:
@Test public void getName() { String name = "paramName"; new Expectations() { { part.getName(); result = name; } }; Assert.assertEquals(name, multipartFile.getName()); }
|
### Question:
PartToMultipartFile implements MultipartFile { @Override public String getOriginalFilename() { return part.getSubmittedFileName(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer:
@Test public void getOriginalFilename() { String submittedFileName = "fileName"; new Expectations() { { part.getSubmittedFileName(); result = submittedFileName; } }; Assert.assertEquals(submittedFileName, multipartFile.getOriginalFilename()); }
|
### Question:
PartToMultipartFile implements MultipartFile { @Override public String getContentType() { return part.getContentType(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer:
@Test public void getContentType() { String contentType = "json"; new Expectations() { { part.getContentType(); result = contentType; } }; Assert.assertEquals(contentType, multipartFile.getContentType()); }
|
### Question:
PartToMultipartFile implements MultipartFile { @Override public long getSize() { return part.getSize(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer:
@Test public void getSize() { long size = 10; new Expectations() { { part.getSize(); result = size; } }; Assert.assertEquals(size, multipartFile.getSize()); }
|
### Question:
PartToMultipartFile implements MultipartFile { @Override public void transferTo(File dest) throws IOException, IllegalStateException { part.write(dest.getPath()); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer:
@Test public void transferTo() throws IllegalStateException, IOException { File dest = new File("/dest"); Holder<String> destName = new Holder<>(); new MockUp<Part>(part) { @Mock void write(String fileName) throws IOException { destName.value = fileName; } }; multipartFile.transferTo(dest); Assert.assertEquals(dest.getPath(), destName.value); }
|
### Question:
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Class<InvocationException> getExceptionClass() { return InvocationException.class; } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); }### Answer:
@Test public void getExceptionClass() { Assert.assertEquals(InvocationException.class, converter.getExceptionClass()); }
|
### Question:
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Response convert(SwaggerInvocation swaggerInvocation, InvocationException e) { return Response.failResp(e); } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); }### Answer:
@Test public void convert(@Mocked SwaggerInvocation swaggerInvocation, @Mocked InvocationException e) { Response response = converter.convert(swaggerInvocation, e); Assert.assertSame(e, response.getResult()); }
|
### Question:
CommonExceptionData extends DynamicObject { public String getMessage() { return message; } CommonExceptionData(); CommonExceptionData(String message); CommonExceptionData(String code, String message); String getCode(); CommonExceptionData setCode(String code); String getMessage(); CommonExceptionData setMessage(String message); @Override String toString(); }### Answer:
@Test void should_decode_dynamic_field_from_json() { String json = "{\"message\":\"msg\",\"k\":\"v\"}"; CommonExceptionData data = Json.decodeValue(json, CommonExceptionData.class); assertThat(data.getMessage()).isEqualTo("msg"); assertThat(data.getDynamic()).isEqualTo(of("k", "v")); assertThat(Json.encode(data)).isEqualTo(json); }
|
### Question:
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Class<Throwable> getExceptionClass() { return null; } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); }### Answer:
@Test public void getExceptionClass() { Assert.assertNull(converter.getExceptionClass()); }
|
### Question:
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Response convert(SwaggerInvocation swaggerInvocation, Throwable e) { LOGGER.error("invoke failed, invocation={}", swaggerInvocation.getInvocationQualifiedName(), e); return Response.failResp(swaggerInvocation.getInvocationType(), e); } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); }### Answer:
@Test public void convert(@Mocked SwaggerInvocation swaggerInvocation, @Mocked Error e) { Response response = converter.convert(swaggerInvocation, e); Assert.assertSame(e, ((InvocationException) response.getResult()).getCause()); }
|
### Question:
ExceptionFactory { public static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { return exceptionToProducerResponseConverters.convertExceptionToResponse(swaggerInvocation, e); } private ExceptionFactory(); static InvocationException create(StatusType status,
Object exceptionOrErrorData); static InvocationException createConsumerException(Object errorData); static InvocationException createProducerException(Object errorData); static InvocationException convertConsumerException(Throwable e); static InvocationException convertConsumerException(Throwable e, String errorMsg); static InvocationException convertProducerException(Throwable e); static InvocationException convertProducerException(Throwable e, String errorMsg); static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); static Throwable unwrapIncludeInvocationException(Throwable throwable); @SuppressWarnings("unchecked") static T unwrap(Throwable throwable); static final int PRODUCER_INNER_STATUS_CODE; static final String PRODUCER_INNER_REASON_PHRASE; static final StatusType PRODUCER_INNER_STATUS; static final int CONSUMER_INNER_STATUS_CODE; static final String CONSUMER_INNER_REASON_PHRASE; static final StatusType CONSUMER_INNER_STATUS; }### Answer:
@Test public void convertExceptionToResponse() { Error error = new Error("test"); Response response = ExceptionFactory.convertExceptionToResponse(null, error); Assert.assertSame(Status.OK, response.getStatus()); Assert.assertEquals("response from error: test", response.getResult()); }
|
### Question:
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); InvocationContext getParentContext(); InvocationType getInvocationType(); String getInvocationQualifiedName(); void onBusinessMethodStart(); void onBusinessMethodFinish(); void onBusinessFinish(); }### Answer:
@Test public void construct_withContext() { InvocationContext parentContext = new InvocationContext(); parentContext.addContext("k", "v"); parentContext.addLocalContext("k", 1); ContextUtils.setInvocationContext(parentContext); try { SwaggerInvocation invocation = new SwaggerInvocation(); Assert.assertSame(parentContext, invocation.getParentContext()); Assert.assertEquals("v", invocation.getContext("k")); Assert.assertEquals(1, (int) invocation.getLocalContext("k")); } finally { ContextUtils.removeInvocationContext(); } }
@Test public void construct_noContext() { SwaggerInvocation invocation = new SwaggerInvocation(); Assert.assertNull(invocation.getParentContext()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.