Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: RestOperationMeta { public boolean isFormData() { return formData; } void init(OperationMeta operationMeta); boolean isDownloadFile(); boolean isFormData(); void setOperationMeta(OperationMeta operationMeta); String getAbsolutePath(); void setAbsolutePath(String absolutePath); PathRegExp getAbsolutePathRegExp(); boolean isAbsoluteStaticPath(); RestParam getParamByName(String name); RestParam getParamByIndex(int index); OperationMeta getOperationMeta(); URLPathBuilder getPathBuilder(); List<RestParam> getParamList(); ProduceProcessor findProduceProcessor(String type); ProduceProcessor ensureFindProduceProcessor(HttpServletRequestEx requestEx); ProduceProcessor ensureFindProduceProcessor(String acceptType); String getHttpMethod(); List<String> getFileKeys(); List<String> getProduces(); }### Answer: @Test public void testFormDataFlagTrue() { findOperation("form"); assertThat(operationMeta.isFormData(), is(true)); } @Test public void testFormDataFlagFalse() { findOperation("json"); assertThat(operationMeta.isFormData(), is(false)); }
### Question: ZeroConfigClient { public boolean register() { String serviceInstanceId = doRegister( ClientUtil.convertToRegisterDataModel(selfMicroserviceInstance, selfMicroservice)); return StringUtils.isNotEmpty(serviceInstanceId); } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService, MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked( ZeroConfigRegistryService zeroConfigRegistryService, MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName, String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice( Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance( MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer: @Test public void test_register_withCorrectData_RegisterShouldSucceed() { boolean returnedResult = target.register(); Assert.assertTrue(returnedResult); } @Test public void test_register_MulticastThrowException_RegisterShouldFail() throws IOException { doThrow(IOException.class).when(multicastSocket).send(anyObject()); boolean returnedResult = target.register(); Assert.assertFalse(returnedResult); }
### Question: URLPathBuilder { public String createRequestPath(Map<String, Object> args) throws Exception { URLPathStringBuilder builder = new URLPathStringBuilder(); genPathString(builder, args); genQueryString(builder, args); return builder.build(); } URLPathBuilder(String rawPath, Map<String, RestParam> paramMap); String createRequestPath(Map<String, Object> args); String createPathString(Map<String, Object> args); }### Answer: @Test public void testMultiQuery() throws Exception { Map<String, RestParam> paramMap = new LinkedHashMap<>(); addParam("strArr", String[].class, QueryParameter::new, paramMap); addParam("intArr", int[].class, QueryParameter::new, paramMap); URLPathBuilder urlPathBuilder = new URLPathBuilder("/path", paramMap); Map<String, Object> parameters = new HashMap<>(); parameters.put("strArr", new Object[] {"a", "b", "c"}); parameters.put("intArr", new Object[] {1, 2, 3}); Assert.assertEquals("/path?strArr=a&strArr=b&strArr=c&intArr=1&intArr=2&intArr=3", urlPathBuilder.createRequestPath(parameters)); parameters.put("strArr", new Object[] {}); parameters.put("intArr", new Object[] {1, 2, 3}); Assert.assertEquals("/path?intArr=1&intArr=2&intArr=3", urlPathBuilder.createRequestPath(parameters)); parameters.put("strArr", new Object[] {"a", "b", "c"}); parameters.put("intArr", new Object[] {}); Assert.assertEquals("/path?strArr=a&strArr=b&strArr=c", urlPathBuilder.createRequestPath(parameters)); parameters.put("strArr", new Object[] {}); parameters.put("intArr", new Object[] {}); Assert.assertEquals("/path", urlPathBuilder.createRequestPath(parameters)); }
### Question: RestProducerInvocation extends AbstractRestInvocation { public void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx, List<HttpServerFilter> httpServerFilters) { this.transport = transport; this.requestEx = requestEx; this.responseEx = responseEx; this.httpServerFilters = httpServerFilters; requestEx.setAttribute(RestConst.REST_REQUEST, requestEx); try { findRestOperation(); } catch (InvocationException e) { sendFailResponse(e); return; } scheduleInvocation(); } void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx, List<HttpServerFilter> httpServerFilters); }### Answer: @Test public void invokeSendFail(@Mocked InvocationException expected) { restProducerInvocation = new MockUp<RestProducerInvocation>() { @Mock void sendFailResponse(Throwable throwable) { throwableOfSendFailResponse = throwable; } @Mock void findRestOperation() { throw expected; } @Mock void scheduleInvocation() { throw new IllegalStateException("must not invoke scheduleInvocation"); } }.getMockInstance(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); Assert.assertSame(expected, throwableOfSendFailResponse); } @Test public void invokeNormal() { restProducerInvocation = new MockUp<RestProducerInvocation>() { @Mock void findRestOperation() { restProducerInvocation.restOperationMeta = restOperationMeta; } @Mock void scheduleInvocation() { scheduleInvocation = true; } }.getMockInstance(); requestEx = new AbstractHttpServletRequest() { }; restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); Assert.assertTrue(scheduleInvocation); Assert.assertSame(requestEx, requestEx.getAttribute(RestConst.REST_REQUEST)); }
### Question: RestProducerInvocation extends AbstractRestInvocation { protected void findRestOperation() { MicroserviceMeta selfMicroserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); findRestOperation(selfMicroserviceMeta); } void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx, List<HttpServerFilter> httpServerFilters); }### Answer: @Test public void findRestOperationNameFromRegistry() { Microservice microservice = new Microservice(); microservice.setServiceName("ms"); new Expectations(ServicePathManager.class) { { ServicePathManager.getServicePathManager(microserviceMeta); result = null; } }; restProducerInvocation = new RestProducerInvocation(); initRestProducerInvocation(); expectedException.expect(Exception.class); expectedException.expectMessage("[message=Not Found]"); restProducerInvocation.findRestOperation(); } @Test public void findRestOperationNormal(@Mocked ServicePathManager servicePathManager, @Mocked OperationLocator locator) { requestEx = new AbstractHttpServletRequest() { @Override public String getRequestURI() { return "/path"; } @Override public String getMethod() { return "GET"; } @Override public String getHeader(String name) { return "ms"; } }; Map<String, String> pathVars = new HashMap<>(); new Expectations(ServicePathManager.class) { { ServicePathManager.getServicePathManager(microserviceMeta); result = servicePathManager; servicePathManager.producerLocateOperation(anyString, anyString); result = locator; locator.getPathVarMap(); result = pathVars; locator.getOperation(); result = restOperationMeta; } }; restProducerInvocation = new RestProducerInvocation(); initRestProducerInvocation(); restProducerInvocation.findRestOperation(); Assert.assertSame(restOperationMeta, restProducerInvocation.restOperationMeta); Assert.assertSame(pathVars, requestEx.getAttribute(RestConst.PATH_PARAMETERS)); }
### Question: VertxRestInvocation extends RestProducerInvocation { @Override protected void createInvocation() { super.createInvocation(); RoutingContext routingContext = ((VertxServerRequestToHttpServletRequest) this.requestEx).getContext(); VertxHttpTransportContext transportContext = new VertxHttpTransportContext(routingContext, requestEx, responseEx, produceProcessor); invocation.setTransportContext(transportContext); routingContext.put(RestConst.REST_INVOCATION_CONTEXT, this.invocation); } }### Answer: @Test public void testCreateInvocation() { new MockUp<RestProducerInvocation>() { @Mock void createInvocation() { } }; VertxRestInvocation vertxRestInvocation = new VertxRestInvocation(); VertxServerRequestToHttpServletRequest requestEx = Mockito.mock(VertxServerRequestToHttpServletRequest.class); RoutingContext routingContext = Mockito.mock(RoutingContext.class); Invocation invocation = Mockito.mock(Invocation.class); Deencapsulation.setField( vertxRestInvocation, "requestEx", requestEx); Deencapsulation.setField( vertxRestInvocation, "invocation", invocation); Mockito.when(requestEx.getContext()).thenReturn(routingContext); Deencapsulation.invoke(vertxRestInvocation, "createInvocation"); Mockito.verify(routingContext, Mockito.times(1)).put(RestConst.REST_INVOCATION_CONTEXT, invocation); }
### Question: Utils { public static String findActualPath(String path, int pathIndex) { if (pathIndex <= 0) { return path; } int fromIndex = 0; int counter = pathIndex; char[] chars = path.toCharArray(); for (int i = 0; i < chars.length; i++) { if (chars[i] == '/') { if (--counter < 0) { fromIndex = i; break; } } } return fromIndex > 0 ? path.substring(fromIndex) : ""; } private Utils(); static String findActualPath(String path, int pathIndex); }### Answer: @Test public void testUtisl() { Assert.assertEquals(Utils.findActualPath("/a/b/c", -1), "/a/b/c"); Assert.assertEquals(Utils.findActualPath("/a/b/c", 0), "/a/b/c"); Assert.assertEquals(Utils.findActualPath("/a/b/c", 1), "/b/c"); Assert.assertEquals(Utils.findActualPath("/a/b/c", 2), "/c"); Assert.assertEquals(Utils.findActualPath("/a/b/c", 3), ""); Assert.assertEquals(Utils.findActualPath("/a/b/c", 100), ""); }
### Question: InspectorBootListener implements BootListener { @Override public int getOrder() { return Short.MAX_VALUE; } @Override int getOrder(); @Override void onAfterTransport(BootEvent event); }### Answer: @Test public void getOrder() { Assert.assertEquals(Short.MAX_VALUE, new InspectorBootListener().getOrder()); }
### Question: InspectorImpl { @Path("/schemas") @GET public Collection<String> getSchemaIds() { return schemas.keySet(); } InspectorImpl(SCBEngine scbEngine, InspectorConfig inspectorConfig, Map<String, String> schemas); SCBEngine getScbEngine(); InspectorConfig getInspectorConfig(); void setPriorityPropertyManager(PriorityPropertyManager priorityPropertyManager); @Path("/schemas") @GET Collection<String> getSchemaIds(); @Path("/download/schemas") @GET @ApiResponse(code = 200, message = "", response = File.class) Response downloadSchemas(@QueryParam("format") SchemaFormat format); @Path("/schemas/{schemaId}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getSchemaContentById(@PathParam("schemaId") String schemaId, @QueryParam("format") SchemaFormat format, @QueryParam("download") boolean download); @Path("/{path : .+}") @GET @ApiResponse(code = 200, message = "", response = File.class) Response getStaticResource(@PathParam("path") String path); @Path("/dynamicProperties") @GET List<DynamicPropertyView> dynamicProperties(); @Path("/priorityProperties") @GET List<PriorityPropertyView> priorityProperties(); }### Answer: @Test public void getSchemaIds() { Assert.assertThat(inspector.getSchemaIds(), Matchers.contains("schema1", "schema2")); }
### Question: ZeroConfigClient { public Microservice getMicroservice(String microserviceId) { if (selfMicroservice.getServiceId().equals(microserviceId)) { return selfMicroservice; } else { return ClientUtil .convertToClientMicroservice(zeroConfigRegistryService.getMicroservice(microserviceId)); } } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService, MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked( ZeroConfigRegistryService zeroConfigRegistryService, MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName, String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice( Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance( MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer: @Test public void test_getMicroservice_forOtherService_shouldCallZeroConfigRegistryService() { when(zeroConfigRegistryService.getMicroservice(otherServiceId)) .thenReturn(prepareServerServiceInstance(true)); Microservice returnedResult = target.getMicroservice(otherServiceId); Assert.assertEquals(otherServiceId, returnedResult.getServiceId()); verify(zeroConfigRegistryService, times(1)).getMicroservice(otherServiceId); }
### Question: AbstractTransport implements Transport { protected void setListenAddressWithoutSchema(String addressWithoutSchema) { setListenAddressWithoutSchema(addressWithoutSchema, null); } @Override Endpoint getPublishEndpoint(); @Override Endpoint getEndpoint(); @Override Object parseAddress(String address); static final String ENDPOINT_KEY; }### Answer: @Test(expected = IllegalArgumentException.class) public void testMyAbstractTransportException(@Mocked TransportManager manager) { MyAbstractTransport transport = new MyAbstractTransport(); transport.setListenAddressWithoutSchema(":127.0.0.1:9090"); }
### Question: TransportManager { protected Map<String, List<Transport>> groupByName() { Map<String, List<Transport>> groups = new HashMap<>(); for (Transport transport : transports) { List<Transport> list = groups.computeIfAbsent(transport.getName(), name -> new ArrayList<>()); list.add(transport); } return groups; } void clearTransportBeforeInit(); void addTransportBeforeInit(Transport transport); void addTransportsBeforeInit(List<Transport> transports); void init(SCBEngine scbEngine); Transport findTransport(String transportName); }### Answer: @Test public void testGroupByName(@Mocked Transport t1, @Mocked Transport t2_1, @Mocked Transport t2_2) { new Expectations() { { t1.getName(); result = "t1"; t2_1.getName(); result = "t2"; t2_2.getName(); result = "t2"; } }; TransportManager manager = new TransportManager(); manager.addTransportsBeforeInit(Arrays.asList(t1, t2_1, t2_2)); Map<String, List<Transport>> groups = manager.groupByName(); Assert.assertEquals(2, groups.size()); Assert.assertEquals(1, groups.get("t1").size()); Assert.assertEquals(t1, groups.get("t1").get(0)); Assert.assertEquals(2, groups.get("t2").size()); Assert.assertEquals(t2_1, groups.get("t2").get(0)); Assert.assertEquals(t2_2, groups.get("t2").get(1)); }
### Question: TransportManager { protected void checkTransportGroup(List<Transport> group) { Map<Integer, Transport> orderMap = new HashMap<>(); for (Transport transport : group) { Transport existTransport = orderMap.putIfAbsent(transport.getOrder(), transport); if (existTransport != null) { throw new ServiceCombException(String.format("%s and %s have the same order %d", existTransport.getClass().getName(), transport.getClass().getName(), transport.getOrder())); } } } void clearTransportBeforeInit(); void addTransportBeforeInit(Transport transport); void addTransportsBeforeInit(List<Transport> transports); void init(SCBEngine scbEngine); Transport findTransport(String transportName); }### Answer: @Test public void testCheckTransportGroupInvalid(@Mocked Transport t1, @Mocked Transport t2) { new Expectations() { { t1.getOrder(); result = 1; t2.getOrder(); result = 1; } }; TransportManager manager = new TransportManager(); List<Transport> group = Arrays.asList(t1, t2); try { manager.checkTransportGroup(group); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals( "org.apache.servicecomb.core.$Impl_Transport and org.apache.servicecomb.core.$Impl_Transport have the same order 1", e.getMessage()); } } @Test public void testCheckTransportGroupValid(@Mocked Transport t1, @Mocked Transport t2) { new Expectations() { { t1.getOrder(); result = 1; t2.getOrder(); result = 2; } }; TransportManager manager = new TransportManager(); List<Transport> group = Arrays.asList(t1, t2); try { manager.checkTransportGroup(group); } catch (ServiceCombException e) { Assert.fail("must not throw exception: " + e.getMessage()); } }
### Question: ZeroConfigClient { public String getSchema(String microserviceId, String schemaId) { LOGGER.info("Retrieve schema content for Microservice ID: {}, Schema ID: {}", microserviceId, schemaId); if (selfMicroservice.getServiceId().equals(microserviceId)) { return selfMicroservice.getSchemaMap().computeIfPresent(schemaId, (k, v) -> v); } else { return null; } } private ZeroConfigClient(ZeroConfigRegistryService zeroConfigRegistryService, MulticastSocket multicastSocket); @VisibleForTesting ZeroConfigClient initZeroConfigClientWithMocked( ZeroConfigRegistryService zeroConfigRegistryService, MulticastSocket multicastSocket); void init(); boolean register(); boolean unregister(); List<Microservice> getAllMicroservices(); Microservice getMicroservice(String microserviceId); String getSchema(String microserviceId, String schemaId); MicroserviceInstance findMicroserviceInstance(String serviceId, String instanceId); MicroserviceInstances findServiceInstances(String appId, String providerServiceName, String strVersionRule); Microservice getSelfMicroservice(); @VisibleForTesting void setSelfMicroservice( Microservice selfMicroservice); MicroserviceInstance getSelfMicroserviceInstance(); @VisibleForTesting void setSelfMicroserviceInstance( MicroserviceInstance selfMicroserviceInstance); static ZeroConfigClient INSTANCE; }### Answer: @Test public void test_getSchema_forSelfMicroservice_shouldNotCallZeroConfigRegistryService_And_Succeed() { String returnedResult = target.getSchema(selfServiceId, schemaId1); Assert.assertEquals(schemaContent1, returnedResult); verifyZeroInteractions(zeroConfigRegistryService); } @Test public void test_getSchema_forOtherMicroservice_shouldReturnNull() { String returnedResult = target.getSchema(otherServiceId, schemaId1); Assert.assertNull(returnedResult); }
### Question: SimpleLoadBalanceFilter implements Filter { @Override public CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode) { if (invocation.getEndpoint() != null) { return nextNode.onFilter(invocation); } invocation.setEndpoint(selectEndpoint(invocation)); return nextNode.onFilter(invocation); } SimpleLoadBalanceFilter(); @Override CompletableFuture<Response> onFilter(Invocation invocation, FilterNode nextNode); Endpoint selectEndpoint(Invocation invocation); }### Answer: @Test public void should_invoke_next_directly_when_invocation_already_has_endpoint() throws ExecutionException, InterruptedException { Response response = Response.ok("ok"); new Expectations() { { invocation.getEndpoint(); result = endpoint; nextNode.onFilter(invocation); result = CompletableFuture.completedFuture(response); } }; Response result = filter.onFilter(invocation, nextNode).get(); assertThat(result).isSameAs(response); new Verifications() { { discoveryContext.setInputParameters(invocation); times = 0; } }; }
### Question: ProducerInvocationFlow { public void run() { CompletableFuture.completedFuture(null) .thenApply(v -> invocationCreator.create()) .exceptionally(this::sendCreateInvocationException) .thenAccept(this::tryRunInvocation); } ProducerInvocationFlow(InvocationCreator invocationCreator); ProducerInvocationFlow(InvocationCreator invocationCreator, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx); void run(); }### Answer: @Test public void should_send_exception_response_when_failed_to_create_invocation() { RuntimeException exception = new RuntimeExceptionWithoutStackTrace(); TestFlow flow = new TestFlow(() -> { throw exception; }); flow.run(); assertThat(sendException).isSameAs(exception); } @Test public void should_start_invocation_when_succeed_to_create_invocation() { mockFilterChain(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); new Verifications() { { invocation.onStart((HttpServletRequestEx) any, anyLong); times = 1; } }; } @Test public void should_send_response_when_invocation_success() { mockFilterChain(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); assertThat(sendInvocation).isSameAs(invocation); } @Test public void should_finish_invocation_when_invocation_success() { mockFilterChain(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); new Verifications() { { invocation.onFinish((Response) any); times = 1; } }; } @Test public void should_send_response_when_invocation_fail() { mockInvocationFailed(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); assertThat(sendInvocation).isSameAs(invocation); } @Test public void should_finish_invocation_when_invocation_fail() { mockInvocationFailed(); TestFlow flow = new TestFlow(() -> invocation); flow.run(); new Verifications() { { invocation.onFinish((Response) any); times = 1; } }; }
### Question: ProducerProviderManager { public void init() { registerProducerMetas(producerMetas); for (ProducerProvider provider : producerProviderList) { List<ProducerMeta> producerMetas = provider.init(); if (producerMetas == null) { LOGGER.warn("ProducerProvider {} not provide any producer.", provider.getClass().getName()); continue; } registerProducerMetas(producerMetas); } } ProducerProviderManager(SCBEngine scbEngine); List<ProducerProvider> getProducerProviderList(); void init(); void addProducerMeta(String schemaId, Object instance); void addProducerMeta(ProducerMeta producerMeta); SchemaMeta registerSchema(String schemaId, Object instance); SchemaMeta registerSchema(String schemaId, Class<?> schemaInterface, Object instance); }### Answer: @Test public void allowedNoProvider() { new ProducerProviderManager(null).init(); }
### Question: EndpointDiscoveryFilter extends AbstractEndpointDiscoveryFilter { @Override public int getOrder() { return Short.MAX_VALUE; } @Override int getOrder(); }### Answer: @Test public void getOrder() { Assert.assertEquals(Short.MAX_VALUE, filter.getOrder()); }
### Question: EndpointDiscoveryFilter extends AbstractEndpointDiscoveryFilter { @Override protected String findTransportName(DiscoveryContext context, DiscoveryTreeNode parent) { Invocation invocation = context.getInputParameters(); return invocation.getConfigTransportName(); } @Override int getOrder(); }### Answer: @Test public void getTransportName() { new Expectations() { { invocation.getConfigTransportName(); result = Const.RESTFUL; } }; Assert.assertEquals(Const.RESTFUL, filter.findTransportName(context, null)); }
### Question: EndpointDiscoveryFilter extends AbstractEndpointDiscoveryFilter { @Override protected Object createEndpoint(String transportName, String endpoint, MicroserviceInstance instance) { Transport transport = SCBEngine.getInstance().getTransportManager().findTransport(transportName); if (transport == null) { LOGGER.info("not deployed transport {}, ignore {}.", transportName, endpoint); return null; } return new Endpoint(transport, endpoint, instance); } @Override int getOrder(); }### Answer: @Test public void createEndpointNullTransport() { Assert.assertNull(filter.createEndpoint(Const.RESTFUL, "", null)); } @Test public void createEndpointNormal(@Mocked Transport transport, @Mocked MicroserviceInstance instance) { String endpoint = "rest: Object address = new Object(); new Expectations(scbEngine.getTransportManager()) { { scbEngine.getTransportManager().findTransport(Const.RESTFUL); result = transport; transport.parseAddress(endpoint); result = address; } }; Endpoint ep = (Endpoint) filter.createEndpoint(Const.RESTFUL, endpoint, instance); Assert.assertSame(transport, ep.getTransport()); Assert.assertSame(address, ep.getAddress()); Assert.assertSame(instance, ep.getMicroserviceInstance()); Assert.assertEquals(endpoint, ep.getEndpoint()); }
### Question: Endpoint { public Endpoint(Transport transport, String endpoint) { this(transport, endpoint, null); } Endpoint(Transport transport, String endpoint); Endpoint(Transport transport, String endpoint, MicroserviceInstance instance); Endpoint(Transport transport, String endpoint, MicroserviceInstance instance, Object address); String getEndpoint(); MicroserviceInstance getMicroserviceInstance(); Transport getTransport(); Object getAddress(); @Override String toString(); }### Answer: @Test public void testEndpoint(@Mocked Transport transport) { new Expectations() { { transport.parseAddress("rest: result = "rest: } }; Endpoint endpoint = new Endpoint(transport, "rest: Assert.assertEquals(endpoint.getAddress(), "rest: Assert.assertEquals(endpoint.getEndpoint(), "rest: Assert.assertEquals(endpoint.getTransport(), transport); Assert.assertEquals(endpoint.toString(), "rest: }
### Question: BraveTraceIdGenerator implements TraceIdGenerator { @Override public String generate() { return Long.toHexString(Platform.get().nextTraceIdHigh()); } @Override String getTraceIdKeyName(); @Override String generate(); }### Answer: @Test public void generateStringId() { TraceIdGenerator traceIdGenerator = new BraveTraceIdGenerator(); assertNotEquals(traceIdGenerator.generate(), traceIdGenerator.generate()); String traceId = traceIdGenerator.generate(); try { Long.parseLong(traceId, 16); } catch (NumberFormatException e) { fail("wrong traceId format: " + traceId); } }
### Question: TransportClientHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { Transport transport = invocation.getTransport(); log.debug( "Sending request {} to {}", invocation.getMicroserviceQualifiedName(), invocation.getEndpoint().getEndpoint()); transport.send(invocation, asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); static final TransportClientHandler INSTANCE; }### Answer: @Test public void test() throws Exception { when(invocation.getTransport()).thenReturn(transport); when(invocation.getEndpoint()).thenReturn(endpoint); transportClientHandler.handle(invocation, asyncResp); verify(transport).send(invocation, asyncResp); }
### Question: ProducerOperationHandler implements Handler { protected Response processException(SwaggerInvocation invocation, Throwable e) { if (e instanceof InvocationTargetException) { e = ((InvocationTargetException) e).getTargetException(); } return ExceptionFactory.convertExceptionToResponse(invocation, e); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); void completableFutureInvoke(Invocation invocation, SwaggerProducerOperation producerOperation, AsyncResponse asyncResp); @SuppressWarnings("unchecked") void doCompletableFutureInvoke(Invocation invocation, SwaggerProducerOperation producerOperation, AsyncResponse asyncResp); void syncInvoke(Invocation invocation, SwaggerProducerOperation producerOperation, AsyncResponse asyncResp); Response doInvoke(Invocation invocation, SwaggerProducerOperation producerOperation); static final ProducerOperationHandler INSTANCE; }### Answer: @Test public void processException_normal(@Mocked SwaggerInvocation invocation) { Error error = new Error("abc"); Response response = handler.processException(invocation, error); Assert.assertSame(Status.OK, response.getStatus()); Assert.assertEquals("response from error: abc", response.getResult()); } @Test public void processException_InvocationTargetException(@Mocked SwaggerInvocation invocation) { Error error = new Error("abc"); InvocationTargetException targetException = new InvocationTargetException(error); Response response = handler.processException(invocation, error); Assert.assertSame(Status.OK, response.getStatus()); Assert.assertEquals("response from error: abc", response.getResult()); }
### Question: CseApplicationListener implements ApplicationListener<ApplicationEvent>, Ordered, ApplicationContextAware { @Override public void onApplicationEvent(ApplicationEvent event) { if (initEventClass.isInstance(event)) { if (applicationContext instanceof AbstractApplicationContext) { ((AbstractApplicationContext) applicationContext).registerShutdownHook(); } SCBEngine scbEngine = SCBEngine.getInstance(); scbEngine.setApplicationContext(applicationContext); scbEngine.setFilterChainsManager(applicationContext.getBean(FilterChainsManager.class)); scbEngine.getConsumerProviderManager().getConsumerProviderList() .addAll(applicationContext.getBeansOfType(ConsumerProvider.class).values()); scbEngine.getProducerProviderManager().getProducerProviderList() .addAll(applicationContext.getBeansOfType(ProducerProvider.class).values()); scbEngine.addBootListeners(applicationContext.getBeansOfType(BootListener.class).values()); scbEngine.run(); } else if (event instanceof ContextClosedEvent) { if (SCBEngine.getInstance() != null) { SCBEngine.getInstance().destroy(); } } } @Override void setApplicationContext(ApplicationContext applicationContext); void setInitEventClass(Class<?> initEventClass); @Override int getOrder(); @Override void onApplicationEvent(ApplicationEvent event); }### Answer: @Test public void onApplicationEvent_close(@Mocked ContextClosedEvent contextClosedEvent) { SCBEngine scbEngine = SCBBootstrap.createSCBEngineForTest(); scbEngine.setStatus(SCBStatus.UP); CseApplicationListener listener = new CseApplicationListener(); listener.onApplicationEvent(contextClosedEvent); Assert.assertEquals(SCBStatus.DOWN, scbEngine.getStatus()); scbEngine.destroy(); }
### Question: InvocationFinishEvent extends InvocationWithResponseEvent { public long getNanoCurrent() { return nanoCurrent; } InvocationFinishEvent(Invocation invocation, Response response); long getNanoCurrent(); }### Answer: @Test public void construct(@Mocked Invocation invocation, @Mocked Response response) { InvocationStageTrace stageTrace = new InvocationStageTrace(invocation); long time = 123; new MockUp<System>() { @Mock long nanoTime() { return time; } }; new Expectations() { { invocation.getInvocationStageTrace(); result = stageTrace; } }; stageTrace.finish(); event = new InvocationFinishEvent(invocation, response); Assert.assertEquals(time, event.getNanoCurrent()); Assert.assertSame(invocation, event.getInvocation()); Assert.assertSame(response, event.getResponse()); }
### Question: MultipartFilePropertyCreator implements PropertyCreator { @Override public Property createProperty() { return new FileProperty(); } @Override Property createProperty(); @Override Class<?>[] classes(); }### Answer: @Test public void createProperty() { Property property = multipartFilePropertyCreator.createProperty(); Assert.assertThat(property, Matchers.instanceOf(FileProperty.class)); }
### Question: MultipartFilePropertyCreator implements PropertyCreator { @Override public Class<?>[] classes() { return classes; } @Override Property createProperty(); @Override Class<?>[] classes(); }### Answer: @Test public void classes() { Class<?>[] classes = multipartFilePropertyCreator.classes(); Assert.assertThat(classes, Matchers.arrayContaining(MultipartFile.class)); }
### Question: RequestPartAnnotationProcessor extends AbstractSpringmvcSerializableParameterProcessor<FormParameter, RequestPart> { @Override public Type getProcessType() { return RequestPart.class; } @Override Type getProcessType(); @Override String getParameterName(RequestPart annotation); @Override HttpParameterType getHttpParameterType(RequestPart parameterAnnotation); }### Answer: @Test public void getProcessType() { Assert.assertEquals(requestPartAnnotationProcessor.getProcessType(), RequestPart.class); }
### Question: RequestPartAnnotationProcessor extends AbstractSpringmvcSerializableParameterProcessor<FormParameter, RequestPart> { @Override public String getParameterName(RequestPart annotation) { String value = annotation.value(); if (value.isEmpty()) { value = annotation.name(); } return value; } @Override Type getProcessType(); @Override String getParameterName(RequestPart annotation); @Override HttpParameterType getHttpParameterType(RequestPart parameterAnnotation); }### Answer: @Test public void getParameterName_fromValue() { Parameter[] parameters = producerMethod.getParameters(); Parameter stringParam = parameters[0]; RequestPart stringParamAnnotation = stringParam.getAnnotation(RequestPart.class); Assert.assertThat(requestPartAnnotationProcessor.getParameterName(stringParamAnnotation), Matchers.is("stringParam")); } @Test public void getParameterName_fromName() { Parameter[] parameters = producerMethod.getParameters(); Parameter intParam = parameters[1]; RequestPart intParamAnnotation = intParam.getAnnotation(RequestPart.class); Assert.assertThat(requestPartAnnotationProcessor.getParameterName(intParamAnnotation), Matchers.is("intParam")); }
### Question: RequestPartAnnotationProcessor extends AbstractSpringmvcSerializableParameterProcessor<FormParameter, RequestPart> { @Override public HttpParameterType getHttpParameterType(RequestPart parameterAnnotation) { return HttpParameterType.FORM; } @Override Type getProcessType(); @Override String getParameterName(RequestPart annotation); @Override HttpParameterType getHttpParameterType(RequestPart parameterAnnotation); }### Answer: @Test public void getHttpParameterType() { Assert.assertThat(requestPartAnnotationProcessor.getHttpParameterType(null), Matchers.is(HttpParameterType.FORM)); }
### Question: MethodUtils { public static List<Method> findSwaggerMethods(Class<?> cls) { Method[] methods = cls.getMethods(); List<Method> result = new ArrayList<>(methods.length); for (Method m : methods) { if (!isSkipMethod(cls, m)) { result.add(m); } } result.sort(Comparator.comparing(MethodUtils::findSwaggerMethodName)); return result; } static List<Method> findSwaggerMethods(Class<?> cls); static Map<String, Method> findSwaggerMethodsMapOfOperationId(Class<?> cls); static boolean isSkipMethod(Class<?> cls, Method method); static String findSwaggerMethodName(Method method); }### Answer: @Test public void testGetClassMethods() throws Exception { List<Method> methods = MethodUtils.findSwaggerMethods(Hello2Endpoint.class); Assert.assertEquals(3, methods.size()); Assert.assertEquals(Hello2Endpoint.class, methods.get(0).getDeclaringClass()); Assert.assertEquals(Hello2Endpoint.class, methods.get(1).getDeclaringClass()); Assert.assertEquals(Hello2Endpoint.class, methods.get(2).getDeclaringClass()); methods = MethodUtils.findSwaggerMethods(HelloEndpoint.class); Assert.assertEquals(2, methods.size()); Assert.assertEquals(HelloEndpoint.class, methods.get(0).getDeclaringClass()); Assert.assertEquals(AbstractBaseClass.class, methods.get(1).getDeclaringClass()); methods = MethodUtils.findSwaggerMethods(ServiceInterface.class); Assert.assertEquals(3, methods.size()); Assert.assertEquals(BaseInterface.class, methods.get(0).getDeclaringClass()); Assert.assertEquals(BaseInterface.class, methods.get(1).getDeclaringClass()); Assert.assertEquals(ServiceInterface.class, methods.get(2).getDeclaringClass()); }
### Question: ApiOperationProcessor implements MethodAnnotationProcessor<ApiOperation> { private void convertTags(String[] tags, Operation operation) { if (tags == null \|\| tags.length == 0) { return; } for (String tag : tags) { if (StringUtils.isEmpty(tag)) { continue; } operation.addTag(tag); } } Type getProcessType(); @Override void process(SwaggerGenerator swaggerGenerator, OperationGenerator operationGenerator, ApiOperation apiOperationAnnotation); }### Answer: @Test public void testConvertTags() { SwaggerOperation swaggerOperation = swaggerOperations.findOperation("function"); assertThat(swaggerOperation.getOperation().getTags(), containsInAnyOrder("tag1", "tag2")); }
### Question: ApiProcessor implements ClassAnnotationProcessor<Api> { @Override public void process(SwaggerGenerator swaggerGenerator, Api api) { setTags(swaggerGenerator, api); SwaggerUtils.setCommaConsumes(swaggerGenerator.getSwagger(), api.consumes()); SwaggerUtils.setCommaProduces(swaggerGenerator.getSwagger(), api.produces()); } @Override Type getProcessType(); @Override void process(SwaggerGenerator swaggerGenerator, Api api); }### Answer: @Test public void process() { SwaggerOperations swaggerOperations = SwaggerOperations.generate(SwaggerTestTarget.class); SwaggerOperation swaggerOperation = swaggerOperations.findOperation("op"); assertThat(swaggerOperation.getOperation().getTags(), contains("tag1", "tag2")); assertThat(swaggerOperation.getSwagger().getConsumes(), Matchers.contains(MediaType.APPLICATION_JSON)); assertThat(swaggerOperation.getSwagger().getProduces(), Matchers.contains(MediaType.APPLICATION_JSON)); }
### Question: PartPropertyCreator implements PropertyCreator { @Override public Class<?>[] classes() { return classes; } @Override Property createProperty(); @Override Class<?>[] classes(); }### Answer: @SuppressWarnings("unchecked") @Test public void classes() { Assert.assertThat(creator.classes(), Matchers.arrayContaining(Part.class)); }
### Question: PartPropertyCreator implements PropertyCreator { @Override public Property createProperty() { return new FileProperty(); } @Override Property createProperty(); @Override Class<?>[] classes(); }### Answer: @Test public void createProperty() { Assert.assertThat(creator.createProperty(), Matchers.instanceOf(FileProperty.class)); }
### Question: ModelResolverExt extends ModelResolver { @VisibleForTesting protected void setType(JavaType type, Map<String, Object> vendorExtensions) { if (SwaggerGeneratorFeature.isLocalExtJavaClassInVendor()) { vendorExtensions.put(SwaggerConst.EXT_JAVA_CLASS, type.toCanonical()); } } ModelResolverExt(); @Override Model resolve(JavaType type, ModelConverterContext context, Iterator<ModelConverter> next); @Override Property resolveProperty(JavaType propType, ModelConverterContext context, Annotation[] annotations, Iterator<ModelConverter> next); }### Answer: @Test public void setType() { JavaType type = TypeFactory.defaultInstance().constructCollectionType(List.class, String.class); resolver.setType(type, vendorExtensions); Assert.assertEquals("java.util.List<java.lang.String>", vendorExtensions.get(SwaggerConst.EXT_JAVA_CLASS)); }
### Question: JsonPropertyIntrospector extends SwaggerAnnotationIntrospector { @SuppressWarnings("deprecation") @Override public String findEnumValue(Enum<?> value) { try { JsonProperty annotation = value.getClass().getField(value.name()).getAnnotation(JsonProperty.class); if (null == annotation \|\| StringUtils.isEmpty(annotation.value())) { return super.findEnumValue(value); } return annotation.value(); } catch (NoSuchFieldException e) { return super.findEnumValue(value); } } @SuppressWarnings("deprecation") @Override String findEnumValue(Enum<?> value); }### Answer: @Test public void findEnumValue() { JsonPropertyIntrospector introspector = new JsonPropertyIntrospector(); assertEquals("AB", introspector.findEnumValue(TestEnum.AB)); assertEquals("C-D", introspector.findEnumValue(TestEnum.C_D)); assertEquals("E.F", introspector.findEnumValue(TestEnum.E_F)); assertEquals("HI", introspector.findEnumValue(TestEnum.HI)); }
### Question: JaxrsConsumerResponseMapper implements ConsumerResponseMapper { @Override public Object mapResponse(Response response) { ResponseBuilder responseBuilder = javax.ws.rs.core.Response.status(response.getStatus()).entity(response.getResult()); Map<String, List<Object>> headers = response.getHeaders().getHeaderMap(); if (headers == null) { return responseBuilder.build(); } for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null) { continue; } for (Object value : entry.getValue()) { if (value != null) { responseBuilder.header(entry.getKey(), value); } } } return responseBuilder.build(); } @Override Object mapResponse(Response response); }### Answer: @SuppressWarnings("unchecked") @Test public void jaxrsResponse() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("jaxrsResponse"); Response jaxrsResponse = (Response) operation.getResponseMapper().mapResponse(response); Assert.assertEquals(result, jaxrsResponse.getEntity()); Assert.assertTrue(jaxrsResponse.getHeaders().isEmpty()); } @Test public void jaxrsResponseWithHeaders() { SwaggerConsumerOperation operation = swaggerConsumer.findOperation("jaxrsResponse"); response.getHeaders().addHeader("h", "v1").addHeader("h", "v2").addHeader("h", (Object) null); response.getHeaders().getHeaderMap().put("h1", null); Response jaxrsResponse = (Response) operation.getResponseMapper().mapResponse(response); Assert.assertEquals(result, jaxrsResponse.getEntity()); Assert.assertEquals(1, jaxrsResponse.getHeaders().size()); Assert.assertThat(jaxrsResponse.getHeaders().get("h"), Matchers.contains("v1", "v2")); }
### Question: JaxrsProducerResponseMapper implements ProducerResponseMapper { @Override public Response mapResponse(StatusType status, Object response) { javax.ws.rs.core.Response jaxrsResponse = (javax.ws.rs.core.Response) response; Response cseResponse = Response.status(jaxrsResponse.getStatusInfo()).entity(jaxrsResponse.getEntity()); MultivaluedMap<String, Object> headers = jaxrsResponse.getHeaders(); for (Entry<String, List<Object>> entry : headers.entrySet()) { if (entry.getValue() == null \|\| entry.getValue().isEmpty()) { continue; } cseResponse.getHeaders().addHeader(entry.getKey(), entry.getValue()); } return cseResponse; } @Override Response mapResponse(StatusType status, Object response); }### Answer: @Test public void mapResponse_withoutHeaders() { new Expectations() { { jaxrsResponse.getStatusInfo(); result = Status.OK; jaxrsResponse.getEntity(); result = "result"; } }; Response response = mapper.mapResponse(null, jaxrsResponse); Assert.assertEquals(Status.OK, response.getStatus()); Assert.assertEquals("result", response.getResult()); Assert.assertNull(response.getHeaders().getHeaderMap()); } @Test public void mapResponse_withHeaders() { MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>(); headers.add("h", "v"); new Expectations() { { jaxrsResponse.getStatusInfo(); result = Status.OK; jaxrsResponse.getEntity(); result = "result"; jaxrsResponse.getHeaders(); result = headers; } }; Response response = mapper.mapResponse(null, jaxrsResponse); Assert.assertEquals(Status.OK, response.getStatus()); Assert.assertEquals("result", response.getResult()); Assert.assertEquals(1, response.getHeaders().getHeaderMap().size()); Assert.assertThat(response.getHeaders().getHeader("h"), Matchers.contains("v")); }
### Question: JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { return Response.class.equals(producerType); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType); }### Answer: @Test public void isMatch_true() { Assert.assertTrue(factory.isMatch(Response.class)); } @Test public void isMatch_false() { Assert.assertFalse(factory.isMatch(String.class)); }
### Question: JaxrsProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { return new JaxrsProducerResponseMapper(); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType); }### Answer: @Test public void createResponseMapper() { Assert.assertThat(factory.createResponseMapper(null, null), Matchers.instanceOf(JaxrsProducerResponseMapper.class)); }
### Question: DefaultParameterNameProvider implements ParameterNameProvider { @Override public List<String> getParameterNames(Constructor<?> constructor) { return methodCache.computeIfAbsent(constructor, k -> getParameterNamesEx(constructor)); } @Override List<String> getParameterNames(Constructor<?> constructor); @Override List<String> getParameterNames(Method method); }### Answer: @Test public void testMethod() throws NoSuchMethodException { Method method = validatorForTest.getMethod("add", int.class, int.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("a", "b")); method = validatorForTest.getMethod("sayHi", String.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("hi")); method = validatorForTest.getMethod("sayHello", ValidatorForTest.Student.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("student")); method = validatorForTest.getMethod("setTest", String.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("grade")); method = validatorForTest.getMethod("getNumber"); Assert.assertTrue(parameterNameProvider.getParameterNames(method).isEmpty()); method = validatorForTest.getMethod("setNumber", int.class); Assert.assertThat(parameterNameProvider.getParameterNames(method), Matchers.contains("number")); } @Test public void testConstructor() throws NoSuchMethodException { Constructor<ValidatorForTest> constructor = validatorForTest.getConstructor(String.class, int.class); Assert.assertThat(parameterNameProvider.getParameterNames(constructor), Matchers.contains("grade", "number")); constructor = validatorForTest.getConstructor(); Assert.assertTrue(parameterNameProvider.getParameterNames(constructor).isEmpty()); }
### Question: SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public boolean isMatch(Type producerType) { if (!ParameterizedType.class.isAssignableFrom(producerType.getClass())) { return false; } return ((ParameterizedType) producerType).getRawType().equals(ResponseEntity.class); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType); }### Answer: @Test public void isMatch_true() { Method method = ReflectUtils.findMethod(this.getClass(), "responseEntity"); Assert.assertTrue(factory.isMatch(method.getGenericReturnType())); } @Test public void isMatch_Parameterized_false() { Method method = ReflectUtils.findMethod(this.getClass(), "list"); Assert.assertFalse(factory.isMatch(method.getGenericReturnType())); } @Test public void isMatch_false() { Assert.assertFalse(factory.isMatch(String.class)); }
### Question: SpringmvcProducerResponseMapperFactory implements ProducerResponseMapperFactory { @Override public ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType) { Type realProducerType = ((ParameterizedType) producerType).getActualTypeArguments()[0]; ProducerResponseMapper realMapper = factorys.createResponseMapper(realProducerType); return new SpringmvcProducerResponseMapper(realMapper); } @Override boolean isMatch(Type producerType); @Override ProducerResponseMapper createResponseMapper(ResponseMapperFactorys<ProducerResponseMapper> factorys, Type producerType); }### Answer: @Test public void createResponseMapper() { Method responseEntityMethod = ReflectUtils.findMethod(this.getClass(), "responseEntity"); ProducerResponseMapper mapper = factory .createResponseMapper(factorys, responseEntityMethod.getGenericReturnType()); Assert.assertThat(mapper, Matchers.instanceOf(SpringmvcProducerResponseMapper.class)); ResponseEntity<String[]> responseEntity = new ResponseEntity<>(new String[] {"a", "b"}, HttpStatus.OK); Response response = mapper.mapResponse(null, responseEntity); Assert.assertThat(response.getResult(), Matchers.arrayContaining("a", "b")); }
### Question: PartToMultipartFile implements MultipartFile { @Override public String getName() { return part.getName(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer: @Test public void getName() { String name = "paramName"; new Expectations() { { part.getName(); result = name; } }; Assert.assertEquals(name, multipartFile.getName()); }
### Question: PartToMultipartFile implements MultipartFile { @Override public String getOriginalFilename() { return part.getSubmittedFileName(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer: @Test public void getOriginalFilename() { String submittedFileName = "fileName"; new Expectations() { { part.getSubmittedFileName(); result = submittedFileName; } }; Assert.assertEquals(submittedFileName, multipartFile.getOriginalFilename()); }
### Question: PartToMultipartFile implements MultipartFile { @Override public String getContentType() { return part.getContentType(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer: @Test public void getContentType() { String contentType = "json"; new Expectations() { { part.getContentType(); result = contentType; } }; Assert.assertEquals(contentType, multipartFile.getContentType()); }
### Question: PartToMultipartFile implements MultipartFile { @Override public long getSize() { return part.getSize(); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer: @Test public void getSize() { long size = 10; new Expectations() { { part.getSize(); result = size; } }; Assert.assertEquals(size, multipartFile.getSize()); }
### Question: PartToMultipartFile implements MultipartFile { @Override public void transferTo(File dest) throws IOException, IllegalStateException { part.write(dest.getPath()); } PartToMultipartFile(Part part); @Override String getName(); @Override String getOriginalFilename(); @Override String getContentType(); @Override boolean isEmpty(); @Override long getSize(); @Override byte[] getBytes(); @Override InputStream getInputStream(); @Override void transferTo(File dest); }### Answer: @Test public void transferTo() throws IllegalStateException, IOException { File dest = new File("/dest"); Holder<String> destName = new Holder<>(); new MockUp<Part>(part) { @Mock void write(String fileName) throws IOException { destName.value = fileName; } }; multipartFile.transferTo(dest); Assert.assertEquals(dest.getPath(), destName.value); }
### Question: InvocationExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<InvocationException> { @Override public Class<InvocationException> getExceptionClass() { return InvocationException.class; } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); }### Answer: @Test public void getExceptionClass() { Assert.assertEquals(InvocationException.class, converter.getExceptionClass()); }
### Question: InvocationExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<InvocationException> { @Override public Response convert(SwaggerInvocation swaggerInvocation, InvocationException e) { return Response.failResp(e); } @Override Class<InvocationException> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, InvocationException e); }### Answer: @Test public void convert(@Mocked SwaggerInvocation swaggerInvocation, @Mocked InvocationException e) { Response response = converter.convert(swaggerInvocation, e); Assert.assertSame(e, response.getResult()); }
### Question: CommonExceptionData extends DynamicObject { public String getMessage() { return message; } CommonExceptionData(); CommonExceptionData(String message); CommonExceptionData(String code, String message); String getCode(); CommonExceptionData setCode(String code); String getMessage(); CommonExceptionData setMessage(String message); @Override String toString(); }### Answer: @Test void should_decode_dynamic_field_from_json() { String json = "{\"message\":\"msg\",\"k\":\"v\"}"; CommonExceptionData data = Json.decodeValue(json, CommonExceptionData.class); assertThat(data.getMessage()).isEqualTo("msg"); assertThat(data.getDynamic()).isEqualTo(of("k", "v")); assertThat(Json.encode(data)).isEqualTo(json); }
### Question: DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Class<Throwable> getExceptionClass() { return null; } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); }### Answer: @Test public void getExceptionClass() { Assert.assertNull(converter.getExceptionClass()); }
### Question: DefaultExceptionToProducerResponseConverter implements ExceptionToProducerResponseConverter<Throwable> { @Override public Response convert(SwaggerInvocation swaggerInvocation, Throwable e) { LOGGER.error("invoke failed, invocation={}", swaggerInvocation.getInvocationQualifiedName(), e); return Response.failResp(swaggerInvocation.getInvocationType(), e); } @Override Class<Throwable> getExceptionClass(); @Override Response convert(SwaggerInvocation swaggerInvocation, Throwable e); }### Answer: @Test public void convert(@Mocked SwaggerInvocation swaggerInvocation, @Mocked Error e) { Response response = converter.convert(swaggerInvocation, e); Assert.assertSame(e, ((InvocationException) response.getResult()).getCause()); }
### Question: ExceptionFactory { public static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e) { return exceptionToProducerResponseConverters.convertExceptionToResponse(swaggerInvocation, e); } private ExceptionFactory(); static InvocationException create(StatusType status, Object exceptionOrErrorData); static InvocationException createConsumerException(Object errorData); static InvocationException createProducerException(Object errorData); static InvocationException convertConsumerException(Throwable e); static InvocationException convertConsumerException(Throwable e, String errorMsg); static InvocationException convertProducerException(Throwable e); static InvocationException convertProducerException(Throwable e, String errorMsg); static Response convertExceptionToResponse(SwaggerInvocation swaggerInvocation, Throwable e); static Throwable unwrapIncludeInvocationException(Throwable throwable); @SuppressWarnings("unchecked") static T unwrap(Throwable throwable); static final int PRODUCER_INNER_STATUS_CODE; static final String PRODUCER_INNER_REASON_PHRASE; static final StatusType PRODUCER_INNER_STATUS; static final int CONSUMER_INNER_STATUS_CODE; static final String CONSUMER_INNER_REASON_PHRASE; static final StatusType CONSUMER_INNER_STATUS; }### Answer: @Test public void convertExceptionToResponse() { Error error = new Error("test"); Response response = ExceptionFactory.convertExceptionToResponse(null, error); Assert.assertSame(Status.OK, response.getStatus()); Assert.assertEquals("response from error: test", response.getResult()); }
### Question: SwaggerInvocation extends InvocationContext { public InvocationContext getParentContext() { return parentContext; } SwaggerInvocation(); InvocationContext getParentContext(); InvocationType getInvocationType(); String getInvocationQualifiedName(); void onBusinessMethodStart(); void onBusinessMethodFinish(); void onBusinessFinish(); }### Answer: @Test public void construct_withContext() { InvocationContext parentContext = new InvocationContext(); parentContext.addContext("k", "v"); parentContext.addLocalContext("k", 1); ContextUtils.setInvocationContext(parentContext); try { SwaggerInvocation invocation = new SwaggerInvocation(); Assert.assertSame(parentContext, invocation.getParentContext()); Assert.assertEquals("v", invocation.getContext("k")); Assert.assertEquals(1, (int) invocation.getLocalContext("k")); } finally { ContextUtils.removeInvocationContext(); } } @Test public void construct_noContext() { SwaggerInvocation invocation = new SwaggerInvocation(); Assert.assertNull(invocation.getParentContext()); }
### Question: 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); }### Answer: @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); }
### Question: 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); }### Answer: @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()); }
### Question: 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); }### Answer: @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")); }
### Question: 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); }### Answer: @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()); }
### Question: 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); }### Answer: @Test public void getFromCompletableFuture() { Assert.assertNull(ContextUtils.getFromCompletableFuture(new CompletableFuture<>())); InvocationContext context = new InvocationContext(); Assert .assertSame(context, ContextUtils.getFromCompletableFuture(new InvocationContextCompletableFuture<>(context))); }
### Question: ResourceToPartConverter implements Converter { @Override public Type getSrcType() { return Resource.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getSrcType() { Assert.assertEquals(Resource.class.getName(), converter.getSrcType().getTypeName()); }
### Question: ResourceToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); }
### Question: 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); }### Answer: @Test public void convert() { Object part = converter.convert(new InputStreamResource(new ByteArrayInputStream(new byte[] {}))); Assert.assertThat(part, Matchers.instanceOf(Part.class)); }
### Question: 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); }### Answer: @Test public void getSrcType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getSrcType().getTypeName()); }
### Question: PartListToPartArrayConverter implements Converter { @Override public Type getTargetType() { return Part[].class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getTargetType() { Assert.assertEquals(Part[].class.getCanonicalName(), converter.getTargetType().getTypeName()); }
### Question: 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); }### Answer: @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)); }
### Question: FileToPartConverter implements Converter { @Override public Type getSrcType() { return File.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getSrcType() { Assert.assertEquals(File.class.getName(), converter.getSrcType().getTypeName()); }
### Question: FileToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); }
### Question: 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); }### Answer: @Test public void convert() { File file = new File("abc"); Object part = converter.convert(file); Assert.assertThat(part, Matchers.instanceOf(Part.class)); }
### Question: InputStreamToPartConverter implements Converter { @Override public Type getSrcType() { return InputStream.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getSrcType() { Assert.assertEquals(InputStream.class.getName(), converter.getSrcType().getTypeName()); }
### Question: InputStreamToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); }
### Question: 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); }### Answer: @Test public void convert() { Object part = converter.convert(new ByteArrayInputStream(new byte[] {})); Assert.assertThat(part, Matchers.instanceOf(Part.class)); }
### Question: PartToPartConverter implements Converter { @Override public Type getSrcType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getSrcType() { Assert.assertEquals(Part.class.getName(), converter.getSrcType().getTypeName()); }
### Question: PartToPartConverter implements Converter { @Override public Type getTargetType() { return Part.class; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void getTargetType() { Assert.assertEquals(Part.class.getName(), converter.getTargetType().getTypeName()); }
### Question: 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); }### Answer: @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()); }
### Question: PartToPartConverter implements Converter { @Override public Object convert(Object value) { return value; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void convert() { Part part = new FilePart("name", "file"); Assert.assertSame(part, converter.convert(part)); }
### Question: 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); }### Answer: @Test public void getSrcType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getSrcType().getTypeName()); }
### Question: 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); }### Answer: @Test public void getTargetType() { Assert.assertEquals("java.util.List<javax.servlet.http.Part>", converter.getTargetType().getTypeName()); }
### Question: PartListToPartListConverter implements Converter { @Override public Object convert(Object value) { return value; } @Override Type getSrcType(); @Override Type getTargetType(); @Override Object convert(Object value); }### Answer: @Test public void convert() { List<Part> parts = Arrays.asList(new FilePart("name", "file")); Assert.assertSame(parts, converter.convert(parts)); }
### Question: 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(); }### Answer: @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); }
### Question: 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(); }### Answer: @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()); }
### Question: ApolloClient { public void refreshApolloConfig() { EXECUTOR .scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.SECONDS); } ApolloClient(UpdateHandler updateHandler); void refreshApolloConfig(); }### Answer: @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()); }
### Question: 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; }### Answer: @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()); }
### Question: 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); }### Answer: @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()); }
### Question: MemberDiscovery { public String getConfigServer() { synchronized (lock) { if (configServerAddresses.isEmpty()) { throw new IllegalStateException("Config center address is not available."); } int index = Math.abs(counter.get() % configServerAddresses.size()); return configServerAddresses.get(index); } } MemberDiscovery(List<String> configCenterUri); String getConfigServer(); @Subscribe void onConnFailEvent(ConnFailEvent e); void refreshMembers(JsonObject members); }### Answer: @Test public void testGetConfigServerURIs() { MemberDiscovery dc = new MemberDiscovery(ConfigCenterConfig.INSTANCE.getServerUri()); assertNotNull(dc.getConfigServer()); }
### Question: ConfigCenterConfig { public List<String> getServerUri() { return Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER).getAccessURL(); } private ConfigCenterConfig(); static void setConcurrentCompositeConfiguration(ConcurrentCompositeConfiguration config); static ConcurrentCompositeConfiguration getConcurrentCompositeConfiguration(); int getRefreshMode(); int getRefreshPort(); String getTenantName(); String getDomainName(); String getToken(); String getApiVersion(); int getRefreshInterval(); int getFirstRefreshInterval(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); @SuppressWarnings("unchecked") String getServiceName(); List<String> getServerUri(); boolean getAutoDiscoveryEnabled(); int getConnectionTimeout(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getEnvironment(); static final ConfigCenterConfig INSTANCE; static final String CONNECTION_TIME_OUT; static final String EVENT_LOOP_SIZE; static final String VERTICAL_INSTANCE_COUNT; static final String IDLE_TIMEOUT_IN_SECONDES; }### Answer: @Test public void getServerUri() { List<String> servers = ConfigCenterConfig.INSTANCE.getServerUri(); Assert.assertEquals("https: Assert.assertEquals("https: }
### Question: ZeroConfigRegistryService { public void heartbeat(ServerMicroserviceInstance receivedInstance) { String serviceId = receivedInstance.getServiceId(); String instanceId = receivedInstance.getInstanceId(); Map<String, ServerMicroserviceInstance> serverMicroserviceInstanceMap = ServerUtil.microserviceInstanceMap .get(serviceId); if (serverMicroserviceInstanceMap != null && serverMicroserviceInstanceMap .containsKey(instanceId)) { ServerMicroserviceInstance instance = serverMicroserviceInstanceMap.get(instanceId); instance.setLastHeartbeatTimeStamp(Instant.now()); } else { receivedInstance.setEvent(REGISTER_EVENT); LOGGER.info( "Received HEARTBEAT event from serviceId: {}, instancdId: {} for the first time. Register it instead.", serviceId, instanceId); this.registerMicroserviceInstance(receivedInstance); } } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }### Answer: @Test public void test_heartbeat_whenInstanceExist_shouldReturnTrue() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); boolean returnedResult = target.heartbeat(serviceId, instanceId); Assert.assertTrue(returnedResult); } @Test public void test_heartbeat_whenInstanceNotExist_shouldReturnFalse() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(false); boolean returnedResult = target.heartbeat(serviceId, instanceId1); Assert.assertFalse(returnedResult); }
### Question: ConfigCenterConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } private ConfigCenterConfig(); static void setConcurrentCompositeConfiguration(ConcurrentCompositeConfiguration config); static ConcurrentCompositeConfiguration getConcurrentCompositeConfiguration(); int getRefreshMode(); int getRefreshPort(); String getTenantName(); String getDomainName(); String getToken(); String getApiVersion(); int getRefreshInterval(); int getFirstRefreshInterval(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); @SuppressWarnings("unchecked") String getServiceName(); List<String> getServerUri(); boolean getAutoDiscoveryEnabled(); int getConnectionTimeout(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getEnvironment(); static final ConfigCenterConfig INSTANCE; static final String CONNECTION_TIME_OUT; static final String EVENT_LOOP_SIZE; static final String VERTICAL_INSTANCE_COUNT; static final String IDLE_TIMEOUT_IN_SECONDES; }### Answer: @Test public void getEnvironment() { Assert.assertEquals("testing", ConfigCenterConfig.INSTANCE.getEnvironment()); System.setProperty("SERVICECOMB_ENV", "development"); ConfigCenterConfig.setConcurrentCompositeConfiguration(ConfigUtil.createLocalConfig()); Assert.assertEquals("development", ConfigCenterConfig.INSTANCE.getEnvironment()); }
### Question: NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void addUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.add(watchedUpdateListener); } NacosConfigurationSourceImpl(); @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(); }### Answer: @Test public void testCreate() throws Exception { NacosConfigurationSourceImpl nacosConfigurationSource = new NacosConfigurationSourceImpl(); nacosConfigurationSource.addUpdateListener(result -> Assert.assertTrue(!result.getAdded().isEmpty())); UpdateHandler udateHandler = Deencapsulation.getField(nacosConfigurationSource, UpdateHandler.class); Map<String, Object> createItems = new HashMap<>(); createItems.put("nacosTestKey", "testValue"); udateHandler.handle(CREATE, createItems); } @Test public void testUpdate() throws Exception { NacosConfigurationSourceImpl nacosConfigurationSource = new NacosConfigurationSourceImpl(); nacosConfigurationSource.addUpdateListener(result -> Assert.assertTrue(!result.getChanged().isEmpty())); UpdateHandler udateHandler = Deencapsulation.getField(nacosConfigurationSource, UpdateHandler.class); Map<String, Object> updateItems = new HashMap<>(); updateItems.put("nacosTestKey", "testValue"); udateHandler.handle(SET, updateItems); }
### Question: NacosConfigurationSourceImpl implements ConfigCenterConfigurationSource { @Override public void removeUpdateListener(WatchedUpdateListener watchedUpdateListener) { listeners.remove(watchedUpdateListener); } NacosConfigurationSourceImpl(); @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(); }### Answer: @Test public void testRemoveUpdateListener() { NacosConfigurationSourceImpl nacosConfigurationSource = new NacosConfigurationSourceImpl(); WatchedUpdateListener watchedUpdateListener = Mockito.mock(WatchedUpdateListener.class); nacosConfigurationSource.addUpdateListener(watchedUpdateListener); nacosConfigurationSource.removeUpdateListener(watchedUpdateListener); Assert.assertTrue(nacosConfigurationSource.getCurrentListeners().isEmpty()); }
### Question: NacosClient { public void refreshNacosConfig() { new ConfigRefresh().refreshConfig(); } NacosClient(UpdateHandler updateHandler); void refreshNacosConfig(); }### Answer: @Test public void refreshNacosConfig() { NacosConfigurationSourceImpl impl = new NacosConfigurationSourceImpl(); UpdateHandler updateHandler = impl.new UpdateHandler(); NacosClient nacosClient = new NacosClient(updateHandler); Map<String, Object> originMap = Deencapsulation.getField(nacosClient, "originalConfigMap"); originMap.put("nacos","12345"); Assert.assertEquals(1, originMap.size()); }
### Question: KieClient { public void refreshKieConfig() { if (enableLongPolling) { EXECUTOR.execute(new ConfigRefresh(serviceUri)); } else { EXECUTOR.scheduleWithFixedDelay(new ConfigRefresh(serviceUri), firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } } KieClient(UpdateHandler updateHandler); void refreshKieConfig(); void destroy(); }### Answer: @SuppressWarnings("unchecked") @Test public void testRefreshKieConfig() { 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(mockKvResponse)); 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); } }; UpdateHandler updateHandler = new KieConfigurationSourceImpl().new UpdateHandler(); KieClient kie = new KieClient(updateHandler); kie.refreshKieConfig(); }
### Question: KieClient { public void destroy() { if (EXECUTOR != null) { EXECUTOR.shutdown(); EXECUTOR = null; } } KieClient(UpdateHandler updateHandler); void refreshKieConfig(); void destroy(); }### Answer: @Test public void destroy() { KieClient kieClient = new KieClient(null); ScheduledExecutorService executor = Deencapsulation.getField(kieClient, "EXECUTOR"); Assert.assertFalse(executor.isShutdown()); executor.shutdown(); Assert.assertTrue(executor.isShutdown()); }
### Question: KieConfig { public String getServerUri() { return finalConfig.getString(SERVER_URL_KEY); } private KieConfig(); static ConcurrentCompositeConfiguration getFinalConfig(); static void setFinalConfig(ConcurrentCompositeConfiguration finalConfig); int getConnectionTimeOut(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getVersion(); String getServiceName(); String getTags(); String getEnvironment(); String getAppName(); String getDomainName(); String getServerUri(); int getRefreshInterval(); int getFirstRefreshInterval(); boolean enableLongPolling(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); static final KieConfig INSTANCE; static final String CONNECTION_TIME_OUT; static final String EVENT_LOOP_SIZE; static final String VERTICAL_INSTANCE_COUNT; static final String IDLE_TIMEOUT_IN_SECONDES; }### Answer: @Test public void getServerUri() { String servers = KieConfig.INSTANCE.getServerUri(); Assert.assertEquals("https: }
### Question: KieConfig { public String getEnvironment() { return BootStrapProperties.readServiceEnvironment(finalConfig); } private KieConfig(); static ConcurrentCompositeConfiguration getFinalConfig(); static void setFinalConfig(ConcurrentCompositeConfiguration finalConfig); int getConnectionTimeOut(); int getEventLoopSize(); int getVerticalInstanceCount(); int getIdleTimeoutInSeconds(); String getVersion(); String getServiceName(); String getTags(); String getEnvironment(); String getAppName(); String getDomainName(); String getServerUri(); int getRefreshInterval(); int getFirstRefreshInterval(); boolean enableLongPolling(); Boolean isProxyEnable(); String getProxyHost(); int getProxyPort(); String getProxyUsername(); String getProxyPasswd(); static final KieConfig INSTANCE; static final String CONNECTION_TIME_OUT; static final String EVENT_LOOP_SIZE; static final String VERTICAL_INSTANCE_COUNT; static final String IDLE_TIMEOUT_IN_SECONDES; }### Answer: @Test public void getEnvironment() { Assert.assertEquals("testing", KieConfig.INSTANCE.getEnvironment()); System.setProperty("SERVICECOMB_ENV", "development"); KieConfig.setFinalConfig(ConfigUtil.createLocalConfig()); Assert.assertEquals("development", KieConfig.INSTANCE.getEnvironment()); }
### Question: KieWatcher { public void refreshConfigItems(Map<String, Object> remoteItems) { String md5Vaule = KieUtil.encrypt(remoteItems.toString()); if (CollectionUtils.isEmpty(remoteItems)) { updateHandler.handle("delete", lastTimeData); lastTimeData = remoteItems; return; } if (StringUtils.isEmpty(refreshRecord)) { refreshRecord = md5Vaule; updateHandler.handle("create", remoteItems); lastTimeData = remoteItems; return; } if (md5Vaule.equals(refreshRecord)) { return; } refreshRecord = md5Vaule; doRefresh(remoteItems); lastTimeData = remoteItems; } private KieWatcher(); void setUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Object> remoteItems); static final KieWatcher INSTANCE; }### Answer: @Test public void testRefreshConfigItems() { boolean status = true; Map<String, Object> configMap = new HashMap<>(); configMap.put("key1", "application1"); configMap.put("key2", "application2"); configMap.put("key3", "application3"); configMap.put("key4", "application4"); Map<String, Object> result = null; try { result = Deencapsulation.invoke(KieWatcher.INSTANCE, "refreshConfigItems", configMap); } catch (Exception e) { status = false; } Assert.assertTrue(status); }
### Question: ZeroConfigRegistryService { public ServerMicroserviceInstance getMicroservice(String microserviceId) { Map<String, ServerMicroserviceInstance> instanceIdMap = ServerUtil.microserviceInstanceMap .get(microserviceId); if (instanceIdMap != null) { List<ServerMicroserviceInstance> serverMicroserviceInstanceList = new ArrayList<>( instanceIdMap.values()); return serverMicroserviceInstanceList.get(0); } return null; } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }### Answer: @Test public void test_getMicroservice_whenServiceExist_shouldReturnService() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); ServerMicroserviceInstance returnedResult = target.getMicroservice(serviceId); Assert.assertNotNull(returnedResult); Assert.assertEquals(serviceId, returnedResult.getServiceId()); } @Test public void test_getMicroservice_whenServiceNotExist_shouldReturnNull() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); ServerMicroserviceInstance returnedResult = target.getMicroservice(otherServiceId); Assert.assertNull(returnedResult); }
### Question: ZeroConfigRegistryService { public List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName) { List<ServerMicroserviceInstance> resultInstanceList = new ArrayList<>(); ServerUtil.microserviceInstanceMap.forEach((serviceId, instanceIdMap) -> { instanceIdMap.forEach((instanceId, instance) -> { if (appId.equals(instance.getAppId()) && serviceName.equals(instance.getServiceName())) { resultInstanceList.add(instance); } }); }); return resultInstanceList; } void registerMicroserviceInstance(ServerMicroserviceInstance receivedInstance); void unregisterMicroserviceInstance(ServerMicroserviceInstance receivedInstance); ServerMicroserviceInstance findServiceInstance(String serviceId, String instanceId); List<ServerMicroserviceInstance> getMicroserviceInstance(String consumerId, String providerId); void heartbeat(ServerMicroserviceInstance receivedInstance); boolean heartbeat(String microserviceId, String microserviceInstanceId); ServerMicroserviceInstance getMicroservice(String microserviceId); List<ServerMicroserviceInstance> findServiceInstances(String appId, String serviceName); }### Answer: @Test public void test_findServiceInstances_whenInstanceExist_shouldReturnInstanceList() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); List<ServerMicroserviceInstance> returnedResult = target .findServiceInstances(appId, serviceName); Assert.assertTrue(!returnedResult.isEmpty()); Assert.assertEquals(2, returnedResult.size()); } @Test public void test_findServiceInstances_whenNoInstanceExist_shouldReturnEmptyInstanceList() { ServerUtil.microserviceInstanceMap = prepareServiceInstanceMap(true); List<ServerMicroserviceInstance> returnedResult = target .findServiceInstances(appId, otherServiceName); Assert.assertTrue(returnedResult.isEmpty()); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.