src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
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); } | @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."); } |
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; } | @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)]")); } |
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(); } | @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; } }; } |
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); } | @Test public void allowedNoProvider() { new ProducerProviderManager(null).init(); } |
EndpointDiscoveryFilter extends AbstractEndpointDiscoveryFilter { @Override public int getOrder() { return Short.MAX_VALUE; } @Override int getOrder(); } | @Test public void getOrder() { Assert.assertEquals(Short.MAX_VALUE, filter.getOrder()); } |
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; } | @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()); } |
EndpointDiscoveryFilter extends AbstractEndpointDiscoveryFilter { @Override protected String findTransportName(DiscoveryContext context, DiscoveryTreeNode parent) { Invocation invocation = context.getInputParameters(); return invocation.getConfigTransportName(); } @Override int getOrder(); } | @Test public void getTransportName() { new Expectations() { { invocation.getConfigTransportName(); result = Const.RESTFUL; } }; Assert.assertEquals(Const.RESTFUL, filter.findTransportName(context, null)); } |
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(); } | @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()); } |
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(); } | @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: } |
BraveTraceIdGenerator implements TraceIdGenerator { @Override public String generate() { return Long.toHexString(Platform.get().nextTraceIdHigh()); } @Override String getTraceIdKeyName(); @Override String generate(); } | @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); } } |
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(); } | @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); } |
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(); } | @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); } |
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(); } | @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()); } |
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(); } | @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")); } |
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(); } | @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)); } |
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(); } | @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()); } |
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(); } | @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()); } |
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(); } | @Test public void onBusinessFinish() { Invocation invocation = new Invocation(endpoint, operationMeta, arguments); mockNonaTime(); invocation.onBusinessFinish(); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishBusiness()); } |
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(); } | @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()); } |
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; } | @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); } |
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; } | @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()); } |
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); } | @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()); } |
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; } | @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()); } |
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); } | @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(); } |
InvocationFinishEvent extends InvocationWithResponseEvent { public long getNanoCurrent() { return nanoCurrent; } InvocationFinishEvent(Invocation invocation, Response response); long getNanoCurrent(); } | @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()); } |
MultipartFilePropertyCreator implements PropertyCreator { @Override public Property createProperty() { return new FileProperty(); } @Override Property createProperty(); @Override Class<?>[] classes(); } | @Test public void createProperty() { Property property = multipartFilePropertyCreator.createProperty(); Assert.assertThat(property, Matchers.instanceOf(FileProperty.class)); } |
MultipartFilePropertyCreator implements PropertyCreator { @Override public Class<?>[] classes() { return classes; } @Override Property createProperty(); @Override Class<?>[] classes(); } | @Test public void classes() { Class<?>[] classes = multipartFilePropertyCreator.classes(); Assert.assertThat(classes, Matchers.arrayContaining(MultipartFile.class)); } |
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); } | @Test public void getProcessType() { Assert.assertEquals(requestPartAnnotationProcessor.getProcessType(), RequestPart.class); } |
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); } | @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")); } |
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); } | @Test public void getHttpParameterType() { Assert.assertThat(requestPartAnnotationProcessor.getHttpParameterType(null), Matchers.is(HttpParameterType.FORM)); } |
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); } | @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()); } |
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); } | @Test public void testConvertTags() { SwaggerOperation swaggerOperation = swaggerOperations.findOperation("function"); assertThat(swaggerOperation.getOperation().getTags(), containsInAnyOrder("tag1", "tag2")); } |
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); } | @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)); } |
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); } | @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)); } |
PartPropertyCreator implements PropertyCreator { @Override public Class<?>[] classes() { return classes; } @Override Property createProperty(); @Override Class<?>[] classes(); } | @SuppressWarnings("unchecked") @Test public void classes() { Assert.assertThat(creator.classes(), Matchers.arrayContaining(Part.class)); } |
PartPropertyCreator implements PropertyCreator { @Override public Property createProperty() { return new FileProperty(); } @Override Property createProperty(); @Override Class<?>[] classes(); } | @Test public void createProperty() { Assert.assertThat(creator.createProperty(), Matchers.instanceOf(FileProperty.class)); } |
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); } | @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)); } |
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); } | @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)); } |
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); } | @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); } |
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); } | @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(""); } |
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); } | @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()); } |
SwaggerUtils { public static void correctResponses(Operation operation) { int okCode = Status.OK.getStatusCode(); String strOkCode = String.valueOf(okCode); Response okResponse = null; for (Entry<String, Response> responseEntry : operation.getResponses().entrySet()) { Response response = responseEntry.getValue(); if (StringUtils.isEmpty(response.getDescription())) { response.setDescription("response of " + responseEntry.getKey()); } if (operation.getResponses().get(strOkCode) != null) { continue; } int statusCode = NumberUtils.toInt(responseEntry.getKey()); if ("default".equals(responseEntry.getKey())) { statusCode = okCode; } if (Family.SUCCESSFUL.equals(Family.familyOf(statusCode))) { okResponse = response; } } if (okResponse != null) { operation.addResponse(strOkCode, okResponse); } } 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); } | @Test public void correctResponsesOperationFixEmptyDescription() { Response response = new Response(); Operation operation = new Operation(); operation.addResponse("200", response); SwaggerUtils.correctResponses(operation); Assert.assertEquals("response of 200", response.getDescription()); }
@Test public void correctResponsesOperationNotChangeExistDescription() { Response response = new Response(); response.setDescription("description"); Operation operation = new Operation(); operation.addResponse("200", response); SwaggerUtils.correctResponses(operation); Assert.assertEquals("description", response.getDescription()); }
@Test public void correctResponsesOperationDefaultTo200() { Response response = new Response(); Operation operation = new Operation(); operation.addResponse("default", response); SwaggerUtils.correctResponses(operation); Assert.assertSame(response, operation.getResponses().get("200")); }
@Test public void correctResponsesOperation2xxTo200() { Response response = new Response(); Operation operation = new Operation(); operation.addResponse("default", new Response()); operation.addResponse("201", response); operation.addResponse("301", new Response()); SwaggerUtils.correctResponses(operation); Assert.assertSame(response, operation.getResponses().get("200")); }
@Test public void correctResponsesNoPaths() { Swagger swagger = new Swagger(); SwaggerUtils.correctResponses(swagger); }
@Test public void correctResponsesHavePaths() { Response response = new Response(); Operation operation = new Operation(); operation.addResponse("200", response); Path path = new Path(); path.set("get", operation); Swagger swagger = new Swagger(); swagger.path("/base", path); SwaggerUtils.correctResponses(swagger); Assert.assertEquals("response of 200", response.getDescription()); } |
ConverterMgr { public static JavaType findJavaType(String type, String format) { String key = genTypeFormatKey(type, format); return TYPE_FORMAT_MAP.get(key); } private ConverterMgr(); static JavaType findJavaType(String type, String format); static JavaType findJavaType(Swagger swagger, Object def); } | @Test public void should_use_swagger_type_when_model_type_is_available() { Model model = swagger.getDefinitions().get("User"); assertThat(SwaggerUtils.getClassName(model.getVendorExtensions())).isEqualTo(User.class.getName()); assertThat(ConverterMgr.findJavaType(swagger, model).getRawClass()).isEqualTo(User.class); }
@Test public void should_use_Object_when_model_type_is_not_available() { Model model = swagger.getDefinitions().get("testEnumBody"); assertThat(SwaggerUtils.getClassName(model.getVendorExtensions())).isEqualTo("gen.cse.ms.ut.testEnumBody"); assertThat(ConverterMgr.findJavaType(swagger, model).getRawClass()).isEqualTo(Object.class); }
@Test public void should_use_Object_when_model_not_declare_type() { Model model = swagger.getDefinitions().get("testFloatBody"); assertThat(SwaggerUtils.getClassName(model.getVendorExtensions())).isNull(); assertThat(ConverterMgr.findJavaType(swagger, model).getRawClass()).isEqualTo(Object.class); }
@Test public void should_support_ref_model() { Operation operation = swagger.getPath("/nestedListString").getPost(); Model model = ((BodyParameter) operation.getParameters().get(0)).getSchema(); assertThat(ConverterMgr.findJavaType(swagger, model).getRawClass()).isEqualTo(Object.class); }
@Test public void should_support_array_model() { Operation operation = swagger.getPath("/nestedListString").getPost(); Model model = operation.getResponses().get("200").getResponseSchema(); assertThat(SwaggerUtils.getClassName(model.getVendorExtensions())).isNull(); assertThat(ConverterMgr.findJavaType(swagger, model).getRawClass()).isEqualTo(List.class); }
@Test public void should_support_boolean_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("bValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Boolean.class); }
@Test public void should_support_int8_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("byteValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Integer.class); }
@Test public void should_support_int16_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("sValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Integer.class); }
@Test public void should_support_int32_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("iValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Integer.class); }
@Test public void should_support_int64_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("lValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Long.class); }
@Test public void should_support_float_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("fValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Float.class); }
@Test public void should_support_double_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("dValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Double.class); }
@Test public void should_support_enum_property_with_available_type() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("enumValue"); assertThat(SwaggerUtils.getClassName(property.getVendorExtensions())) .isEqualTo("org.apache.servicecomb.foundation.test.scaffolding.model.Color"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(Color.class); }
@Test public void should_support_bytes_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("bytes"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(byte[].class); }
@Test public void should_support_string_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("strValue"); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()).isEqualTo(String.class); }
@Test public void should_support_set_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("set"); assertThat(ConverterMgr.findJavaType(swagger, property)) .isEqualTo(TypeFactory.defaultInstance().constructCollectionType( Set.class, String.class)); }
@Test public void should_support_list_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("list"); assertThat(ConverterMgr.findJavaType(swagger, property)) .isEqualTo(TypeFactory.defaultInstance().constructCollectionType( List.class, User.class)); }
@Test public void should_support_map_property() { Model model = swagger.getDefinitions().get("AllType"); Property property = model.getProperties().get("map"); assertThat(ConverterMgr.findJavaType(swagger, property)) .isEqualTo(TypeFactory.defaultInstance().constructMapType( Map.class, String.class, User.class)); }
@Test public void should_support_object_property() { Property property = new ObjectProperty(); assertThat(ConverterMgr.findJavaType(swagger, property).getRawClass()) .isEqualTo(Object.class); } |
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); } | @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")); } |
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); } | @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")); } |
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); } | @Test public void isMatch_true() { Assert.assertTrue(factory.isMatch(Response.class)); }
@Test public void isMatch_false() { Assert.assertFalse(factory.isMatch(String.class)); } |
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); } | @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)); } |
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); } | @Test public void createResponseMapper() { Assert.assertThat(factory.createResponseMapper(null, null), Matchers.instanceOf(JaxrsProducerResponseMapper.class)); } |
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); } | @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()); } |
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); } | @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)); } |
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); } | @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")); } |
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); } | @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")); } |
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); } | @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")); } |
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); } | @Test public void getName() { String name = "paramName"; new Expectations() { { part.getName(); result = name; } }; Assert.assertEquals(name, multipartFile.getName()); } |
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); } | @Test public void getOriginalFilename() { String submittedFileName = "fileName"; new Expectations() { { part.getSubmittedFileName(); result = submittedFileName; } }; Assert.assertEquals(submittedFileName, multipartFile.getOriginalFilename()); } |
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); } | @Test public void getContentType() { String contentType = "json"; new Expectations() { { part.getContentType(); result = contentType; } }; Assert.assertEquals(contentType, multipartFile.getContentType()); } |
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); } | @Test public void getSize() { long size = 10; new Expectations() { { part.getSize(); result = size; } }; Assert.assertEquals(size, multipartFile.getSize()); } |
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); } | @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); } |
SlowInvocationLogger { @Subscribe @AllowConcurrentEvents public void onInvocationFinish(InvocationFinishEvent event) { Invocation invocation = event.getInvocation(); OperationConfig operationConfig = invocation.getOperationMeta().getConfig(); if (!operationConfig.isSlowInvocationEnabled() || invocation.getInvocationStageTrace().calcTotalTime() < operationConfig.getNanoSlowInvocation()) { return; } if (!invocation.isConsumer()) { logSlowProducer(invocation, event.getResponse(), operationConfig); return; } if (invocation.isEdge()) { logSlowEdge(invocation, event.getResponse(), operationConfig); return; } logSlowConsumer(invocation, event.getResponse(), operationConfig); } SlowInvocationLogger(SCBEngine scbEngine); @Subscribe @AllowConcurrentEvents void onInvocationFinish(InvocationFinishEvent event); } | @Test public void disable() { logger.onInvocationFinish(event); Assert.assertTrue(logCollector.getEvents().isEmpty()); }
@Test public void enableButNotSlow() { new Expectations() { { operationConfig.isSlowInvocationEnabled(); result = true; operationConfig.getNanoSlowInvocation(); result = 2; stageTrace.calcTotalTime(); result = 1; } }; logger.onInvocationFinish(event); Assert.assertTrue(logCollector.getEvents().isEmpty()); }
@Test public void consumerSlow(@Mocked Endpoint endpoint) { new Expectations() { { invocation.getEndpoint(); result = endpoint; endpoint.getEndpoint(); result = "rest: invocation.isConsumer(); result = true; invocation.getTraceIdLogger(); result = new TraceIdLogger(invocation); operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = restOperationMeta; operationConfig.isSlowInvocationEnabled(); result = true; operationConfig.getNanoSlowInvocation(); result = 1; stageTrace.calcTotalTime(); result = 1; } }; logger.onInvocationFinish(event); Assert.assertEquals("" + "slow(0 ms) invocation, null:\n" + " http method: null\n" + " url : null\n" + " server : rest: + " status code: 0\n" + " total : 0.0 ms\n" + " prepare : 0.0 ms\n" + " handlers request : 0.0 ms\n" + " client filters request : 0.0 ms\n" + " send request : 0.0 ms\n" + " get connection : 0.0 ms\n" + " write to buf : 0.0 ms\n" + " wait response : 0.0 ms\n" + " wake consumer : 0.0 ms\n" + " client filters response: 0.0 ms\n" + " handlers response : 0.0 ms", logCollector.getEvents().get(0).getMessage()); }
@Test public void edgeSlow(@Mocked Endpoint endpoint) { new Expectations() { { invocation.getEndpoint(); result = endpoint; endpoint.getEndpoint(); result = "rest: invocation.isConsumer(); result = true; invocation.getTraceIdLogger(); result = new TraceIdLogger(invocation); invocation.isEdge(); result = true; operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = restOperationMeta; operationConfig.isSlowInvocationEnabled(); result = true; operationConfig.getNanoSlowInvocation(); result = 1; stageTrace.calcTotalTime(); result = 1; } }; logger.onInvocationFinish(event); Assert.assertEquals("" + "slow(0 ms) invocation, null:\n" + " http method: null\n" + " url : null\n" + " server : rest: + " status code: 0\n" + " total : 0.0 ms\n" + " prepare : 0.0 ms\n" + " threadPoolQueue : 0.0 ms\n" + " server filters request : 0.0 ms\n" + " handlers request : 0.0 ms\n" + " client filters request : 0.0 ms\n" + " send request : 0.0 ms\n" + " get connection : 0.0 ms\n" + " write to buf : 0.0 ms\n" + " wait response : 0.0 ms\n" + " wake consumer : 0.0 ms\n" + " client filters response: 0.0 ms\n" + " handlers response : 0.0 ms\n" + " server filters response: 0.0 ms\n" + " send response : 0.0 ms", logCollector.getEvents().get(0).getMessage()); }
@Test public void producerSlow(@Mocked HttpServletRequestEx requestEx) { new Expectations() { { invocation.getRequestEx(); result = requestEx; invocation.getTraceIdLogger(); result = new TraceIdLogger(invocation); requestEx.getRemoteAddr(); result = "1.1.1.1"; requestEx.getRemotePort(); result = 1234; invocation.isConsumer(); result = false; operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = restOperationMeta; operationConfig.isSlowInvocationEnabled(); result = true; operationConfig.getNanoSlowInvocation(); result = 1; stageTrace.calcTotalTime(); result = 1; } }; logger.onInvocationFinish(event); Assert.assertEquals("" + "slow(0 ms) invocation, null:\n" + " http method: null\n" + " url : null\n" + " client : 1.1.1.1:1234\n" + " status code: 0\n" + " total : 0.0 ms\n" + " prepare : 0.0 ms\n" + " threadPoolQueue : 0.0 ms\n" + " server filters request : 0.0 ms\n" + " handlers request : 0.0 ms\n" + " business execute : 0.0 ms\n" + " handlers response : 0.0 ms\n" + " server filters response: 0.0 ms\n" + " send response : 0.0 ms", logCollector.getEvents().get(0).getMessage()); } |
InvocationExceptionToProducerResponseConverter implements
ExceptionToProducerResponseConverter<InvocationException> { @Override public Class<InvocationException> getExceptionClass() { return InvocationException.class; } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); } | @Test public void getExceptionClass() { Assert.assertEquals(InvocationException.class, converter.getExceptionClass()); } |
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); } | @Test public void convert(@Mocked SwaggerInvocation swaggerInvocation, @Mocked InvocationException e) { Response response = converter.convert(swaggerInvocation, e); Assert.assertSame(e, response.getResult()); } |
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(); } | @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); } |
ExceptionToProducerResponseConverters { public Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { ExceptionToProducerResponseConverter<Throwable> converter = null; Class<?> clazz = e.getClass(); while (converter == null) { converter = exceptionToProducerResponseConverters.get(clazz); if (clazz == Throwable.class) { break; } clazz = clazz.getSuperclass(); } if (converter == null) { converter = defaultConverter; } try { return converter.convert(swaggerInvocation, e); } catch (Throwable throwable) { LOGGER .error("ExceptionToProducerResponseConverter {} cannot throw exception, please fix it.", converter.getClass(), throwable); return Response.failResp(swaggerInvocation.getInvocationType(), e); } } @SuppressWarnings("unchecked") ExceptionToProducerResponseConverters(); Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); } | @Test public void convertExceptionToResponse( @Mocked ExceptionToProducerResponseConverter<Throwable> c1, @Mocked Response r1, @Mocked ExceptionToProducerResponseConverter<Throwable> c2, @Mocked Response r2, @Mocked ExceptionToProducerResponseConverter<Throwable> cDef) { new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(ExceptionToProducerResponseConverter.class); result = Arrays.asList(c1, c2, cDef); c1.getExceptionClass(); result = Throwable.class; c1.convert((SwaggerInvocation) any, (Throwable) any); result = r1; c2.getExceptionClass(); result = Exception.class; c2.convert((SwaggerInvocation) any, (Throwable) any); result = r2; cDef.getExceptionClass(); result = null; } }; ExceptionToProducerResponseConverters exceptionToProducerResponseConverters = new ExceptionToProducerResponseConverters(); Assert.assertSame(r1, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new Throwable())); Assert.assertSame(r2, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new Exception())); Assert.assertSame(r2, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new IllegalStateException())); }
@Test public void convertExceptionToResponse_checkDefaultConverterPriority( @Mocked ExceptionToProducerResponseConverter<Throwable> c1, @Mocked Response r1, @Mocked ExceptionToProducerResponseConverter<Throwable> c2, @Mocked Response r2, @Mocked ExceptionToProducerResponseConverter<Throwable> cDef, @Mocked Response rDef, @Mocked ExceptionToProducerResponseConverter<Throwable> cDef2) { new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(ExceptionToProducerResponseConverter.class); result = Arrays.asList(c1, c2, cDef, cDef2); c1.getExceptionClass(); result = RuntimeException.class; c1.convert((SwaggerInvocation) any, (Throwable) any); result = r1; c2.getExceptionClass(); result = InvocationException.class; c2.convert((SwaggerInvocation) any, (Throwable) any); result = r2; cDef.getExceptionClass(); result = null; cDef.convert((SwaggerInvocation) any, (Throwable) any); result = rDef; cDef2.getExceptionClass(); result = null; } }; ExceptionToProducerResponseConverters exceptionToProducerResponseConverters = new ExceptionToProducerResponseConverters(); Assert.assertSame(r2, exceptionToProducerResponseConverters .convertExceptionToResponse(null, new InvocationException(Status.UNAUTHORIZED, ""))); Assert.assertSame(r1, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException())); Assert.assertSame(rDef, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new IOException())); }
@Test public void convertExceptionToResponse_CheckCommonConvertPriority( @Mocked ExceptionToProducerResponseConverter<RuntimeException0> cR0, @Mocked ExceptionToProducerResponseConverter<RuntimeException0> cR0_LowPriority, @Mocked ExceptionToProducerResponseConverter<RuntimeException1> cR1, @Mocked ExceptionToProducerResponseConverter<RuntimeException> cR, @Mocked ExceptionToProducerResponseConverter<Throwable> cT, @Mocked ExceptionToProducerResponseConverter<?> cDef, @Mocked Response rR0, @Mocked Response rR1, @Mocked Response rR, @Mocked Response rT) { new Expectations(SPIServiceUtils.class) { { SPIServiceUtils.getSortedService(ExceptionToProducerResponseConverter.class); result = Arrays.asList(cR, cR0, cR0_LowPriority, cR1, cDef, cT); cR0.getExceptionClass(); result = RuntimeException0.class; cR0.convert((SwaggerInvocation) any, (RuntimeException0) any); result = rR0; cR0_LowPriority.getExceptionClass(); result = RuntimeException0.class; cR1.getExceptionClass(); result = RuntimeException1.class; cR1.convert((SwaggerInvocation) any, (RuntimeException1) any); result = rR1; cR.getExceptionClass(); result = RuntimeException.class; cR.convert((SwaggerInvocation) any, (RuntimeException) any); result = rR; cT.getExceptionClass(); result = Throwable.class; cT.convert((SwaggerInvocation) any, (Throwable) any); result = rT; cDef.getExceptionClass(); result = null; } }; ExceptionToProducerResponseConverters exceptionToProducerResponseConverters = new ExceptionToProducerResponseConverters(); Assert.assertSame(rR0, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException0_0())); Assert.assertSame(rR0, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException0())); Assert.assertSame(rR1, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException1())); Assert.assertSame(rR, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new RuntimeException())); Assert.assertSame(rT, exceptionToProducerResponseConverters.convertExceptionToResponse(null, new IOException())); } |
DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Class<Throwable> getExceptionClass() { return null; } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); } | @Test public void getExceptionClass() { Assert.assertNull(converter.getExceptionClass()); } |
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); } | @Test public void convert(@Mocked SwaggerInvocation swaggerInvocation, @Mocked Error e) { Response response = converter.convert(swaggerInvocation, e); Assert.assertSame(e, ((InvocationException) response.getResult()).getCause()); } |
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; } | @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()); } |
SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); InvocationContext getParentContext(); InvocationType getInvocationType(); String getInvocationQualifiedName(); void onBusinessMethodStart(); void onBusinessMethodFinish(); void onBusinessFinish(); } | @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()); } |
ZeroConfigRegistryService { public ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId) { Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap == null || serverMicroserviceInstanceMap.isEmpty()) { return null; } return serverMicroserviceInstanceMap.get(instanceId); } 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); } | @Test public void test_findServiceInstance_whenInstanceExist_shouldSucceed() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); ServerMicroserviceInstance returnedResult = target.findServiceInstance(serviceId, instanceId); Assert.assertNotNull(returnedResult); }
@Test public void test_findServiceInstance_whenInstanceNotExist_shouldReturnEmptyOptionalObject() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); ServerMicroserviceInstance returnedResult = target.findServiceInstance(serviceId, instanceId1); Assert.assertNull(returnedResult); } |
InvocationContext { public void addContext(String key, String value) { context.put(key, value); } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); } | @Test public void addContext() { InvocationContext invocationContext = new InvocationContext(); invocationContext.addContext("key1", "value1"); Assert.assertEquals(1, invocationContext.getContext().size()); Assert.assertEquals("value1", invocationContext.getContext("key1")); Map<String, String> otherContext = new HashMap<>(); otherContext.put("key2", "value2"); invocationContext.addContext(otherContext); Assert.assertEquals(2, invocationContext.getContext().size()); Assert.assertEquals("value2", invocationContext.getContext("key2")); InvocationContext invocationContext2 = new InvocationContext(); Map<String, String> otherContext2 = new HashMap<>(); otherContext2.put("key3", "value3"); invocationContext2.context = otherContext2; invocationContext.addContext(invocationContext2); Assert.assertEquals(3, invocationContext.getContext().size()); } |
InvocationContext { public void addLocalContext(String key, Object value) { localContext.put(key, value); } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); } | @Test public void addLocalContext() { InvocationContext invocationContext = new InvocationContext(); invocationContext.addLocalContext("key1", "value1"); Assert.assertEquals(1, invocationContext.getLocalContext().size()); Assert.assertEquals("value1", invocationContext.getLocalContext("key1")); Map<String, Object> otherContext = new HashMap<>(); otherContext.put("key2", "value2"); invocationContext.addLocalContext(otherContext); Assert.assertEquals(2, invocationContext.getLocalContext().size()); Assert.assertEquals("value2", invocationContext.getLocalContext("key2")); } |
InvocationContext { public void setStatus(StatusType status) { this.httpStatus = status; } InvocationContext(); Map<String, String> getContext(); void setContext(Map<String, String> context); void addContext(String key, String value); String getContext(String key); void addContext(InvocationContext otherContext); void addContext(Map<String, String> otherContext); void mergeContext(InvocationContext otherContext); void mergeContext(Map<String, String> otherContext); Map<String, Object> getLocalContext(); void setLocalContext(Map<String, Object> localContext); void addLocalContext(String key, Object value); @SuppressWarnings("unchecked") T getLocalContext(String key); void addLocalContext(Map<String, Object> otherContext); StatusType getStatus(); void setStatus(StatusType status); void setStatus(int statusCode, String reason); void setStatus(int statusCode); @SuppressWarnings("unchecked") T getTransportContext(); void setTransportContext(TransportContext transportContext); } | @Test public void setStatus() { InvocationContext invocationContext = new InvocationContext(); invocationContext.setStatus(200); System.out.println(invocationContext.getStatus().getFamily()); Assert.assertEquals(200, invocationContext.getStatus().getStatusCode()); Assert.assertEquals("OK", invocationContext.getStatus().getReasonPhrase()); Assert.assertEquals(Family.SUCCESSFUL, invocationContext.getStatus().getFamily()); invocationContext.setStatus(200, "TEST"); Assert.assertEquals(200, invocationContext.getStatus().getStatusCode()); Assert.assertEquals("TEST", invocationContext.getStatus().getReasonPhrase()); Assert.assertEquals(Family.SUCCESSFUL, invocationContext.getStatus().getFamily()); } |
ContextUtils { public static InvocationContext getFromCompletableFuture(CompletableFuture<?> future) { if (future instanceof InvocationContextCompletableFuture) { return ((InvocationContextCompletableFuture<?>) future).getContext(); } return null; } private ContextUtils(); static InvocationContext getInvocationContext(); static InvocationContext getAndRemoveInvocationContext(); static void setInvocationContext(InvocationContext invocationContext); static void removeInvocationContext(); static InvocationContext getFromCompletableFuture(CompletableFuture<?> future); } | @Test public void getFromCompletableFuture() { Assert.assertNull(ContextUtils.getFromCompletableFuture(new CompletableFuture<>())); InvocationContext context = new InvocationContext(); Assert .assertSame(context, ContextUtils.getFromCompletableFuture(new InvocationContextCompletableFuture<>(context))); } |
ResourceToPartConverter implements Converter { @Override public Type getSrcType() { return Resource.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getSrcType() { Assert.assertEquals(Resource.class.getName(), converter.getSrcType().getTypeName()); } |
ResourceToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); } |
ResourceToPartConverter implements Converter { @Override public Object convert(Object value) { return new ResourcePart(null, (Resource) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void convert() { Object part = converter.convert(new InputStreamResource(new ByteArrayInputStream(new byte[] {}))); Assert.assertThat(part, Matchers.instanceOf(Part.class)); } |
PartListToPartArrayConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getSrcType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getSrcType().getTypeName()); } |
PartListToPartArrayConverter implements Converter { @Override public Type getTargetType() { return Part[].class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getTargetType() { Assert.assertEquals(Part[].class.getCanonicalName(), converter.getTargetType().getTypeName()); } |
PartListToPartArrayConverter implements Converter { @Override public Object convert(Object value) { if (value == null) { return null; } @SuppressWarnings("unchecked") List<Part> partList = (List<Part>) value; return partList.toArray(new Part[partList.size()]); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void convert() { Object parts = converter.convert(Arrays.asList(new FilePart("name", "file"))); Assert.assertThat(parts, Matchers.instanceOf(Part[].class)); }
@Test public void should_got_null_when_convert_null() { Assert.assertNull(converter.convert(null)); } |
FileToPartConverter implements Converter { @Override public Type getSrcType() { return File.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getSrcType() { Assert.assertEquals(File.class.getName(), converter.getSrcType().getTypeName()); } |
FileToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); } |
FileToPartConverter implements Converter { @Override public Object convert(Object value) { return new FilePart(null, (File) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void convert() { File file = new File("abc"); Object part = converter.convert(file); Assert.assertThat(part, Matchers.instanceOf(Part.class)); } |
InputStreamToPartConverter implements Converter { @Override public Type getSrcType() { return InputStream.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getSrcType() { Assert.assertEquals(InputStream.class.getName(), converter.getSrcType().getTypeName()); } |
InputStreamToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); } |
InputStreamToPartConverter implements Converter { @Override public Object convert(Object value) { return new InputStreamPart(null, (InputStream) value); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void convert() { Object part = converter.convert(new ByteArrayInputStream(new byte[] {})); Assert.assertThat(part, Matchers.instanceOf(Part.class)); } |
PartToPartConverter implements Converter { @Override public Type getSrcType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getSrcType() { Assert.assertEquals(Part.class.getName(), converter.getSrcType().getTypeName()); } |
PartToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); } |
ZeroConfigRegistryService { public List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(providerId); if (instanceIdMap == null || instanceIdMap.isEmpty()) { throw new IllegalArgumentException("Invalid serviceId, serviceId=" + providerId); } return new ArrayList<>(instanceIdMap.values()); } 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); } | @Test(expected = IllegalArgumentException.class) public void test_getMicroserviceInstance_whenServiceHasNoInstance_shouldThrowIllegalArgumentException() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMapWihtoutInstance(); target.getMicroserviceInstance(serviceId, serviceId); }
@Test public void test_getMicroserviceInstance_whenServiceHasInstance_shouldReturnAllInstances() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); List<ServerMicroserviceInstance> returnedResult = target .getMicroserviceInstance(serviceId, serviceId); Assert.assertNotNull(returnedResult); Assert.assertEquals(2, returnedResult.size()); } |
PartToPartConverter implements Converter { @Override public Object convert(Object value) { return value; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void convert() { Part part = new FilePart("name", "file"); Assert.assertSame(part, converter.convert(part)); } |
PartListToPartListConverter implements Converter { @Override public Type getSrcType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getSrcType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getSrcType().getTypeName()); } |
PartListToPartListConverter implements Converter { @Override public Type getTargetType() { return Types.newParameterizedType(List.class, Part.class); } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void getTargetType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getTargetType().getTypeName()); } |
PartListToPartListConverter implements Converter { @Override public Object convert(Object value) { return value; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); } | @Test public void convert() { List<Part> parts = Arrays.asList(new FilePart("name", "file")); Assert.assertSame(parts, converter.convert(parts)); } |
SwaggerEnvironment { public SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger) { Map<Class<?>, ContextArgumentMapperFactory> contextFactorys = SPIServiceUtils .getOrLoadSortedService(ConsumerContextArgumentMapperFactory.class) .stream() .collect(Collectors.toMap(ConsumerContextArgumentMapperFactory::getContextClass, Function.identity())); ResponseMapperFactorys<ConsumerResponseMapper> consumerResponseMapperFactorys = new ResponseMapperFactorys<>(ConsumerResponseMapperFactory.class); SwaggerOperations swaggerOperations = new SwaggerOperations(swagger); SwaggerConsumer consumer = new SwaggerConsumer(); consumer.setConsumerIntf(consumerIntf); for (Method consumerMethod : MethodUtils.findSwaggerMethods(consumerIntf)) { String operationId = findOperationId(consumerMethod); SwaggerOperation swaggerOperation = swaggerOperations.findOperation(operationId); if (swaggerOperation == null) { LOGGER.warn("consumer method {}:{} not exist in contract.", consumerIntf.getName(), consumerMethod.getName()); continue; } ConsumerArgumentsMapperCreator creator = new ConsumerArgumentsMapperCreator( Json.mapper().getSerializationConfig(), contextFactorys, consumerIntf, consumerMethod, swaggerOperation); ArgumentsMapper argsMapper = creator.createArgumentsMapper(); ConsumerResponseMapper responseMapper = consumerResponseMapperFactorys .createResponseMapper(consumerMethod.getGenericReturnType()); SwaggerConsumerOperation op = new SwaggerConsumerOperation(); op.setConsumerClass(consumerIntf); op.setConsumerMethod(consumerMethod); op.setSwaggerOperation(swaggerOperation); op.setArgumentsMapper(argsMapper); op.setResponseMapper(responseMapper); consumer.addOperation(op); } return consumer; } SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger); SwaggerProducer createProducer(Object producerInstance, Swagger swagger); SwaggerProducer createProducer(Object producerInstance, Class<?> schemaInterface, Swagger swagger); } | @Test public void createConsumer_consumerMethodSetBigger() { Swagger swagger = SwaggerGenerator.generate(ContractIntf.class); SwaggerConsumer swaggerConsumer = env.createConsumer(ConsumerIntf.class, swagger); Assert.assertNotNull(swaggerConsumer.findOperation("exist")); Assert.assertNull(swaggerConsumer.findOperation("notExist")); } |
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey); } | @Test public void testConfiguration() { DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: Assert.assertNull(Deployment.getSystemBootStrapInfo("wrong")); }
@Test public void testConfigurationEnv() { System.setProperty("servicecomb.service.registry.address", "https: System.setProperty("servicecomb.config.client.serverUri", "https: DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "https: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: System.getProperties().remove("servicecomb.service.registry.address"); System.getProperties().remove("servicecomb.config.client.serverUri"); }
@Test public void testConfigurationEnvTwo() { System.setProperty("servicecomb.service.registry.address", "https: System.setProperty("servicecomb.config.client.serverUri", "https: DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().size(), 2); Assert.assertEquals(info.getAccessURL().get(0), "https: Assert.assertEquals(info.getAccessURL().get(1), "https: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: Assert.assertEquals(info.getAccessURL().size(), 1); System.getProperties().remove("servicecomb.service.registry.address"); System.getProperties().remove("servicecomb.config.client.serverUri"); } |
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } ApolloConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); } | @Test public void testCreate() throws Exception { ApolloConfigurationSourceImpl apolloConfigurationSource = new ApolloConfigurationSourceImpl(); apolloConfigurationSource.addUpdateListener(result -> Assert.assertTrue(!result.getAdded().isEmpty())); UpdateHandler udateHandler = Deencapsulation.getField(apolloConfigurationSource, UpdateHandler.class); Map<String, Object> createItems = new HashMap<>(); createItems.put("testKey", "testValue"); udateHandler.handle(CREATE, createItems); }
@Test public void testUpdate() throws Exception { ApolloConfigurationSourceImpl apolloConfigurationSource = new ApolloConfigurationSourceImpl(); apolloConfigurationSource.addUpdateListener(result -> Assert.assertTrue(!result.getChanged().isEmpty())); UpdateHandler udateHandler = Deencapsulation.getField(apolloConfigurationSource, UpdateHandler.class); Map<String, Object> updateItems = new HashMap<>(); updateItems.put("testKey", "testValue"); udateHandler.handle(SET, updateItems); } |
ApolloConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } ApolloConfigurationSourceImpl(); @Override boolean isValidSource(Configuration localConfiguration); @Override void init(Configuration localConfiguration); @Override void addUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override void removeUpdateListener(WatchedUpdateListener watchedUpdateListener); @Override Map<String, Object> getCurrentData(); List<WatchedUpdateListener> getCurrentListeners(); } | @Test public void testRemoveUpdateListener() { ApolloConfigurationSourceImpl apolloConfigurationSource = new ApolloConfigurationSourceImpl(); WatchedUpdateListener watchedUpdateListener = Mockito.mock(WatchedUpdateListener.class); apolloConfigurationSource.addUpdateListener(watchedUpdateListener); apolloConfigurationSource.removeUpdateListener(watchedUpdateListener); Assert.assertTrue(apolloConfigurationSource.getCurrentListeners().isEmpty()); } |
ApolloClient { public void refreshApolloConfig() { EXECUTOR .scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.SECONDS); } ApolloClient(UpdateHandler updateHandler); void refreshApolloConfig(); } | @Test public void refreshApolloConfig() { ApolloConfig apolloConfig = ApolloConfig.INSTANCE; RestTemplate rest = Mockito.mock(RestTemplate.class); ResponseEntity<String> responseEntity = new ResponseEntity<>( "{\"apollo\":\"mocked\", \"configurations\":{\"timeout\":1000}}", HttpStatus.OK); Mockito.when(rest.exchange( Matchers.anyString(), Matchers.any(HttpMethod.class), Matchers.<HttpEntity<String>>any(), Matchers.<Class<String>>any())).thenReturn(responseEntity); ApolloConfigurationSourceImpl impl = new ApolloConfigurationSourceImpl(); UpdateHandler updateHandler = impl.new UpdateHandler(); ApolloClient apolloClient = new ApolloClient(updateHandler); Deencapsulation.setField(apolloClient, "rest", rest); ConfigRefresh cr = apolloClient.new ConfigRefresh(apolloConfig.getServerUri()); cr.run(); Map<String, Object> originMap = Deencapsulation.getField(apolloClient, "originalConfigMap"); Assert.assertEquals(1, originMap.size()); } |
ApolloConfig { public String getServiceName() { return finalConfig.getString(APOLLO_SERVICE_NAME); } private ApolloConfig(); static void setConcurrentCompositeConfiguration(Configuration config); Configuration getConcurrentCompositeConfiguration(); String getServiceName(); String getServerUri(); String getToken(); String getEnv(); String getNamespace(); String getServerClusters(); int getRefreshInterval(); int getFirstRefreshInterval(); static final ApolloConfig INSTANCE; } | @Test public void getServiceName() { ApolloConfig instance = ApolloConfig.INSTANCE; Assert.assertEquals("apollo-test", instance.getServiceName()); Assert.assertEquals("http: Assert.assertEquals("DEV", instance.getEnv()); Assert.assertEquals("test-cluster", instance.getServerClusters()); Assert.assertEquals("application", instance.getNamespace()); Assert.assertEquals("xxx", instance.getToken()); Assert.assertEquals(30, instance.getRefreshInterval()); Assert.assertEquals(0, instance.getFirstRefreshInterval()); } |
ConfigCenterClient { public void connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); } | @SuppressWarnings("unchecked") @Test public void testConnectServer(@Mocked ClientPoolManager<HttpClientWithContext> clientMgr) { HttpClients.mockClientPoolManager("config-center", clientMgr); HttpClientRequest request = Mockito.mock(HttpClientRequest.class); Mockito.when(request.method()).thenReturn(HttpMethod.GET); Mockito.when(request.headers()).thenReturn(MultiMap.caseInsensitiveMultiMap()); Buffer rsp = Mockito.mock(Buffer.class); Mockito.when(rsp.toJsonObject()).thenReturn(new JsonObject( "{\"instances\":[{\"status\":\"UP\",\"endpoints\":[\"rest:0.0.0.0:30103\"],\"hostName\":\"125292-0.0.0.0\",\"serviceName\":\"configServer\",\"https\":false}]}")); HttpClientResponse event = Mockito.mock(HttpClientResponse.class); Mockito.when(event.bodyHandler(Mockito.any(Handler.class))).then(invocation -> { Handler<Buffer> handler = invocation.getArgumentAt(0, Handler.class); handler.handle(rsp); return null; }); Mockito.when(event.statusCode()).thenReturn(200); HttpClient httpClient = Mockito.mock(HttpClient.class); Mockito.when( httpClient.get(Mockito.anyInt(), Mockito.anyString(), Mockito.anyString(), Mockito.any(Handler.class))) .then(invocation -> { Handler<HttpClientResponse> handler = invocation.getArgumentAt(3, Handler.class); handler.handle(event); return request; }); new MockUp<HttpClientWithContext>() { @Mock public void runOnContext(RunHandler handler) { handler.run(httpClient); } }; new MockUp<MemberDiscovery>() { @Mock public void refreshMembers(JsonObject members) { Assert.assertTrue(members.size() == 1); } }; UpdateHandler updateHandler = new ConfigCenterConfigurationSourceImpl().new UpdateHandler(); ConfigCenterClient cc = new ConfigCenterClient(updateHandler); cc.connectServer(); }
@Test public void testConnectRefreshModeTwo() { ConfigCenterClient cc2 = new ConfigCenterClient(null); boolean status = false; try { Deencapsulation.setField(cc2, "refreshMode", 2); cc2.connectServer(); } catch (Exception e) { status = true; } Assert.assertFalse(status); } |
ConfigCenterClient { public void destroy() { if (executor != null) { executor.shutdown(); executor = null; } if (heartbeatTask != null) { heartbeatTask.shutdown(); heartbeatTask = null; } } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); } | @Test public void destroy() { ConfigCenterClient configCenterClient = new ConfigCenterClient(null); ScheduledExecutorService executor = Deencapsulation.getField(configCenterClient, "executor"); ScheduledExecutorService heartbeatTask = Executors.newScheduledThreadPool(1); Deencapsulation.setField(configCenterClient, "heartbeatTask", heartbeatTask); Assert.assertFalse(executor.isShutdown()); configCenterClient.destroy(); Assert.assertTrue(executor.isShutdown()); Assert.assertTrue(heartbeatTask.isShutdown()); } |
ParseConfigUtils { private void notifyItemsChangedNeedRefresh(Map<String, Object> before, Map<String, Object> after) { Map<String, Object> itemsCreated = new HashMap<>(); Map<String, Object> itemsDeleted = new HashMap<>(); Map<String, Object> itemsModified = new HashMap<>(); if (before == null || before.isEmpty()) { updateHandler.handle("create", after); return; } if (after == null || after.isEmpty()) { updateHandler.handle("delete", before); return; } for (String itemKey : after.keySet()) { if (!before.containsKey(itemKey)) { itemsCreated.put(itemKey, after.get(itemKey)); } else if (!after.get(itemKey).equals(before.get(itemKey))) { itemsModified.put(itemKey, after.get(itemKey)); } } for (String itemKey : before.keySet()) { if (!after.containsKey(itemKey)) { itemsDeleted.put(itemKey, ""); } } updateHandler.handle("create", itemsCreated); updateHandler.handle("set", itemsModified); updateHandler.handle("delete", itemsDeleted); } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); void initWithUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Map<String, Object>> remoteItems); static ParseConfigUtils getInstance(); String getCurrentVersionInfo(); void refreshConfigItemsIncremental(Map<String, Object> action); } | @Test public void testNotifyItemsChangedNeedRefresh() { boolean status = true; Map<String, Object> before = new HashMap<>(); Map<String, Object> after = new HashMap<>(); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; before.put("test", "testValue"); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; after.put("test", "testValue2"); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.