method2testcases
stringlengths 118
6.63k
|
|---|
### 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:
SwaggerEnvironment { public SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger) { Map<Class<?>, ContextArgumentMapperFactory> contextFactorys = SPIServiceUtils .getOrLoadSortedService(ConsumerContextArgumentMapperFactory.class) .stream() .collect(Collectors.toMap(ConsumerContextArgumentMapperFactory::getContextClass, Function.identity())); ResponseMapperFactorys<ConsumerResponseMapper> consumerResponseMapperFactorys = new ResponseMapperFactorys<>(ConsumerResponseMapperFactory.class); SwaggerOperations swaggerOperations = new SwaggerOperations(swagger); SwaggerConsumer consumer = new SwaggerConsumer(); consumer.setConsumerIntf(consumerIntf); for (Method consumerMethod : MethodUtils.findSwaggerMethods(consumerIntf)) { String operationId = findOperationId(consumerMethod); SwaggerOperation swaggerOperation = swaggerOperations.findOperation(operationId); if (swaggerOperation == null) { LOGGER.warn("consumer method {}:{} not exist in contract.", consumerIntf.getName(), consumerMethod.getName()); continue; } ConsumerArgumentsMapperCreator creator = new ConsumerArgumentsMapperCreator( Json.mapper().getSerializationConfig(), contextFactorys, consumerIntf, consumerMethod, swaggerOperation); ArgumentsMapper argsMapper = creator.createArgumentsMapper(); ConsumerResponseMapper responseMapper = consumerResponseMapperFactorys .createResponseMapper(consumerMethod.getGenericReturnType()); SwaggerConsumerOperation op = new SwaggerConsumerOperation(); op.setConsumerClass(consumerIntf); op.setConsumerMethod(consumerMethod); op.setSwaggerOperation(swaggerOperation); op.setArgumentsMapper(argsMapper); op.setResponseMapper(responseMapper); consumer.addOperation(op); } return consumer; } SwaggerConsumer createConsumer(Class<?> consumerIntf, Swagger swagger); SwaggerProducer createProducer(Object producerInstance, Swagger swagger); SwaggerProducer createProducer(Object producerInstance, Class<?> schemaInterface, Swagger swagger); }### Answer:
@Test public void createConsumer_consumerMethodSetBigger() { Swagger swagger = SwaggerGenerator.generate(ContractIntf.class); SwaggerConsumer swaggerConsumer = env.createConsumer(ConsumerIntf.class, swagger); Assert.assertNotNull(swaggerConsumer.findOperation("exist")); Assert.assertNull(swaggerConsumer.findOperation("notExist")); }
|
### Question:
Deployment { public static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey) { for (DeploymentProvider provider : providerList) { if (provider.getSystemBootStrapInfo(systemKey) != null) { return provider.getSystemBootStrapInfo(systemKey); } } return null; } static SystemBootstrapInfo getSystemBootStrapInfo(String systemKey); }### Answer:
@Test public void testConfiguration() { DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: Assert.assertNull(Deployment.getSystemBootStrapInfo("wrong")); }
@Test public void testConfigurationEnv() { System.setProperty("servicecomb.service.registry.address", "https: System.setProperty("servicecomb.config.client.serverUri", "https: DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "https: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: System.getProperties().remove("servicecomb.service.registry.address"); System.getProperties().remove("servicecomb.config.client.serverUri"); }
@Test public void testConfigurationEnvTwo() { System.setProperty("servicecomb.service.registry.address", "https: System.setProperty("servicecomb.config.client.serverUri", "https: DefaultDeploymentProvider.setConfiguration(ConfigUtil.createLocalConfig()); SystemBootstrapInfo info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_SERVICE_CENTER); Assert.assertEquals(info.getAccessURL().size(), 2); Assert.assertEquals(info.getAccessURL().get(0), "https: Assert.assertEquals(info.getAccessURL().get(1), "https: info = Deployment.getSystemBootStrapInfo(DeploymentProvider.SYSTEM_KEY_CONFIG_CENTER); Assert.assertEquals(info.getAccessURL().get(0), "http: Assert.assertEquals(info.getAccessURL().size(), 1); System.getProperties().remove("servicecomb.service.registry.address"); System.getProperties().remove("servicecomb.config.client.serverUri"); }
|
### 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 connectServer() { if (refreshMode != 0 && refreshMode != 1) { LOGGER.error("refreshMode must be 0 or 1."); return; } ParseConfigUtils.getInstance().initWithUpdateHandler(updateHandler); refreshMembers(memberDiscovery); ConfigRefresh refreshTask = new ConfigRefresh(ParseConfigUtils.getInstance(), memberDiscovery); refreshTask.run(true); executor.scheduleWithFixedDelay(refreshTask, firstRefreshInterval, refreshInterval, TimeUnit.MILLISECONDS); } ConfigCenterClient(ConfigCenterConfigurationSourceImpl.UpdateHandler updateHandler); void connectServer(); void destroy(); static SignRequest createSignRequest(String method, String endpoint, Map<String, String> headers,
InputStream content); }### Answer:
@SuppressWarnings("unchecked") @Test public void testConnectServer(@Mocked ClientPoolManager<HttpClientWithContext> clientMgr) { HttpClients.mockClientPoolManager("config-center", clientMgr); HttpClientRequest request = Mockito.mock(HttpClientRequest.class); Mockito.when(request.method()).thenReturn(HttpMethod.GET); Mockito.when(request.headers()).thenReturn(MultiMap.caseInsensitiveMultiMap()); Buffer rsp = Mockito.mock(Buffer.class); Mockito.when(rsp.toJsonObject()).thenReturn(new JsonObject( "{\"instances\":[{\"status\":\"UP\",\"endpoints\":[\"rest:0.0.0.0:30103\"],\"hostName\":\"125292-0.0.0.0\",\"serviceName\":\"configServer\",\"https\":false}]}")); HttpClientResponse event = Mockito.mock(HttpClientResponse.class); Mockito.when(event.bodyHandler(Mockito.any(Handler.class))).then(invocation -> { Handler<Buffer> handler = invocation.getArgumentAt(0, Handler.class); handler.handle(rsp); return null; }); Mockito.when(event.statusCode()).thenReturn(200); HttpClient httpClient = Mockito.mock(HttpClient.class); Mockito.when( httpClient.get(Mockito.anyInt(), Mockito.anyString(), Mockito.anyString(), Mockito.any(Handler.class))) .then(invocation -> { Handler<HttpClientResponse> handler = invocation.getArgumentAt(3, Handler.class); handler.handle(event); return request; }); new MockUp<HttpClientWithContext>() { @Mock public void runOnContext(RunHandler handler) { handler.run(httpClient); } }; new MockUp<MemberDiscovery>() { @Mock public void refreshMembers(JsonObject members) { Assert.assertTrue(members.size() == 1); } }; UpdateHandler updateHandler = new ConfigCenterConfigurationSourceImpl().new UpdateHandler(); ConfigCenterClient cc = new ConfigCenterClient(updateHandler); cc.connectServer(); }
@Test public void testConnectRefreshModeTwo() { ConfigCenterClient cc2 = new ConfigCenterClient(null); boolean status = false; try { Deencapsulation.setField(cc2, "refreshMode", 2); cc2.connectServer(); } catch (Exception e) { status = true; } Assert.assertFalse(status); }
|
### 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:
ParseConfigUtils { private void notifyItemsChangedNeedRefresh(Map<String, Object> before, Map<String, Object> after) { Map<String, Object> itemsCreated = new HashMap<>(); Map<String, Object> itemsDeleted = new HashMap<>(); Map<String, Object> itemsModified = new HashMap<>(); if (before == null || before.isEmpty()) { updateHandler.handle("create", after); return; } if (after == null || after.isEmpty()) { updateHandler.handle("delete", before); return; } for (String itemKey : after.keySet()) { if (!before.containsKey(itemKey)) { itemsCreated.put(itemKey, after.get(itemKey)); } else if (!after.get(itemKey).equals(before.get(itemKey))) { itemsModified.put(itemKey, after.get(itemKey)); } } for (String itemKey : before.keySet()) { if (!after.containsKey(itemKey)) { itemsDeleted.put(itemKey, ""); } } updateHandler.handle("create", itemsCreated); updateHandler.handle("set", itemsModified); updateHandler.handle("delete", itemsDeleted); } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); void initWithUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Map<String, Object>> remoteItems); static ParseConfigUtils getInstance(); String getCurrentVersionInfo(); void refreshConfigItemsIncremental(Map<String, Object> action); }### Answer:
@Test public void testNotifyItemsChangedNeedRefresh() { boolean status = true; Map<String, Object> before = new HashMap<>(); Map<String, Object> after = new HashMap<>(); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; before.put("test", "testValue"); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; after.put("test", "testValue2"); try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); status = true; try { Deencapsulation.invoke(pc, "notifyItemsChangedNeedRefresh", before, after); } catch (Exception e) { status = false; } Assert.assertTrue(status); }
|
### Question:
ParseConfigUtils { private Map<String, Object> mergeDimensionItems(Map<String, Map<String, Object>> items) { Map<String, Object> flatMap = new HashMap<>(); Set<String> keySet = items.keySet(); if (keySet.contains("application")) { flatMap.putAll(items.get("application")); keySet.remove("application"); } if (!keySet.isEmpty()) { TreeSet<String> sortedKeys = new TreeSet<String>(new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.length() - o2.length(); } }); sortedKeys.addAll(keySet); sortedKeys.forEach(key -> flatMap.putAll(items.get(key))); } return flatMap; } ParseConfigUtils(UpdateHandler updateHandler); private ParseConfigUtils(); void initWithUpdateHandler(UpdateHandler updateHandler); void refreshConfigItems(Map<String, Map<String, Object>> remoteItems); static ParseConfigUtils getInstance(); String getCurrentVersionInfo(); void refreshConfigItemsIncremental(Map<String, Object> action); }### Answer:
@Test public void testMergeDimensionItems() { boolean status = true; Map<String, Object> application = new HashMap<>(); application.put("key1", "application1"); application.put("key2", "application2"); application.put("key3", "application3"); application.put("key4", "application4"); Map<String, Object> service = new HashMap<>(); service.put("key1", "service1"); service.put("key2", "service2"); service.put("key3", "service3"); Map<String, Object> version = new HashMap<>(); version.put("key1", "version1"); version.put("key2", "version1"); Map<String, Object> tag = new HashMap<>(); tag.put("key1", "tag1"); Map<String, Map<String, Object>> items = new LinkedHashMap<String, Map<String, Object>>(); items.put("application", application); items.put("service@app", service); items.put("service@app#version", version); items.put("service@app#version!tag", tag); Map<String, Object> result = null; try { result = Deencapsulation.invoke(pc, "mergeDimensionItems", items); } catch (Exception e) { status = false; } Assert.assertTrue(status); Assert.assertEquals(application.get("key4"), result.get("key4")); Assert.assertEquals(service.get("key3"), result.get("key3")); Assert.assertEquals(version.get("key2"), result.get("key2")); Assert.assertEquals(tag.get("key1"), result.get("key1")); }
|
### 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:
KieUtil { public static Map<String, Object> processValueType(KVDoc kvDoc) { ValueType valueType = parseValueType(kvDoc.getValueType()); if (valueType == (ValueType.YAML) || valueType == (ValueType.YML)) { return Parser.findParser(Parser.CONTENT_TYPE_YAML).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else if (valueType == (ValueType.PROPERTIES)) { return Parser.findParser(Parser.CONTENT_TYPE_PROPERTIES).parse(kvDoc.getValue(), kvDoc.getKey(), true); } else { return Parser.findParser(Parser.CONTENT_TYPE_RAW).parse(kvDoc.getValue(), kvDoc.getKey(), true); } } static String encrypt(String dataStr); static Map<String, Object> getConfigByLabel(KVResponse resp); static Map<String, Object> processValueType(KVDoc kvDoc); }### Answer:
@Test public void test_processValueType() { KVDoc kvDoc = new KVDoc(); kvDoc.setKey("hello"); kvDoc.setValue("world"); Map<String, Object> result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello")); kvDoc.setValueType("text"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello")); kvDoc.setValueType("string"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello")); kvDoc.setValueType("json"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello")); kvDoc.setValueType("yml"); kvDoc.setValue("hello: world"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello.hello")); kvDoc.setValueType("yaml"); kvDoc.setValue("hello: world"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello.hello")); kvDoc.setValueType("properties"); kvDoc.setValue("hello=world"); result = KieUtil.processValueType(kvDoc); Assert.assertEquals("world", result.get("hello.hello")); }
|
### 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()); }
|
### Question:
LoadbalanceExceptionUtils extends ExceptionUtils { public static CseException createLoadbalanceException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); CseException exception = new CseException(code, msg, cause); return exception; } static CseException createLoadbalanceException(String code, Throwable cause, Object... args); static final String CSE_HANDLER_LB_WRONG_RULE; }### Answer:
@Test public void testLoadbalanceExceptionUtils() { assertEquals("servicecomb.handler.lb.wrong.rule", LoadbalanceExceptionUtils.CSE_HANDLER_LB_WRONG_RULE); CseException cseException = LoadbalanceExceptionUtils.createLoadbalanceException("servicecomb.handler.lb.wrong.rule", new Throwable(), "ARGS"); Assert.assertNotNull(cseException); }
|
### Question:
InstancePropertyDiscoveryFilter extends AbstractDiscoveryFilter { protected boolean allowVisit(MicroserviceInstance instance, Map<String, String> filterOptions) { Map<String, String> propertiesMap = instance.getProperties(); for (Entry<String, String> entry : filterOptions.entrySet()) { if (!entry.getValue().equals(propertiesMap.get(entry.getKey()))) { return false; } } return true; } @Override int getOrder(); @Override boolean enabled(); @Override boolean isGroupingFilter(); }### Answer:
@Test public void testAllowVisit() { Map<String, String> filterOptions = new HashMap<>(); Assert.assertTrue(filter.allowVisit(instance, filterOptions)); filterOptions.put("tag0", "value0"); Assert.assertTrue(filter.allowVisit(instance, filterOptions)); filterOptions.put("tag2", "value2"); Assert.assertFalse(filter.allowVisit(instance, filterOptions)); filterOptions.clear(); filterOptions.put("tag0", "value1"); Assert.assertFalse(filter.allowVisit(instance, filterOptions)); }
|
### Question:
ServerDiscoveryFilter extends EndpointDiscoveryFilter { @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 ServiceCombServer(transport, new CacheEndpoint(endpoint, instance)); } }### Answer:
@Test public void createEndpoint_TransportNotExist() { new Expectations(transportManager) { { transportManager.findTransport(anyString); result = null; } }; ServiceCombServer server = (ServiceCombServer) filter.createEndpoint(Const.RESTFUL, null, null); Assert.assertNull(server); }
@Test public void createEndpointNormal() { new Expectations(transportManager) { { transportManager.findTransport(anyString); result = trasport; } }; MicroserviceInstance instance = new MicroserviceInstance(); instance.setInstanceId("0000001"); ServiceCombServer server = (ServiceCombServer) filter .createEndpoint(Const.RESTFUL, "rest: Assert.assertSame(instance, server.getInstance()); Assert.assertSame(trasport, server.getEndpoint().getTransport()); Assert.assertEquals("rest: }
|
### Question:
Configuration { public int getRetryNextServer(String microservice) { return getRetryServer(microservice, RETRY_ON_NEXT); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }### Answer:
@Test public void testConfigurationWithGetpropertyReturnsStringChar() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "tyt"; } }; Configuration.INSTANCE.getRetryNextServer("test"); assertNotNull(Configuration.INSTANCE.getRetryNextServer("test")); }
@Test public void testConfigurationWithGetpropertyReturnsStringNum() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "1234"; } }; Configuration.INSTANCE.getRetryNextServer("test"); assertNotNull(Configuration.INSTANCE.getRetryNextServer("test")); }
|
### Question:
Configuration { public int getRetrySameServer(String microservice) { return getRetryServer(microservice, RETRY_ON_SAME); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }### Answer:
@Test public void testGetRetryOnSameWithGetpropertyReturnsStringChar() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "tyt"; } }; Configuration.INSTANCE.getRetrySameServer("test"); assertNotNull(Configuration.INSTANCE.getRetrySameServer("test")); }
@Test public void testGetRetryOnSameWithGetpropertyReturnsStringNum() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "1234"; } }; Configuration.INSTANCE.getRetrySameServer("test"); assertNotNull(Configuration.INSTANCE.getRetrySameServer("test")); }
|
### Question:
Configuration { public boolean isRetryEnabled(String microservice) { String p = getStringProperty("false", ROOT + microservice + "." + RETRY_ENABLED, ROOT + RETRY_ENABLED); return Boolean.parseBoolean(p); } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }### Answer:
@Test public void testIsRetryEnabledWithGetpropertyReturnsStringChar() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "tyt"; } }; Configuration.INSTANCE.isRetryEnabled("test"); assertNotNull(Configuration.INSTANCE.isRetryEnabled("test")); }
@Test public void testIsRetryEnabledWithGetpropertyReturnsStringNum() { new MockUp<Configuration>() { @Mock private String getProperty(String defaultValue, String... keys) { return "1234"; } }; Configuration.INSTANCE.isRetryEnabled("test"); assertNotNull(Configuration.INSTANCE.isRetryEnabled("test")); }
|
### Question:
Configuration { public int getSuccessiveFailedTimes(String microservice) { final int defaultValue = 5; String p = getStringProperty("5", ROOT + microservice + "." + SUCCESSIVE_FAILED_TIMES, ROOT + SUCCESSIVE_FAILED_TIMES); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }### Answer:
@Test public void testGetSuccessiveFailedTimes() { assertNotNull(Configuration.INSTANCE.getSuccessiveFailedTimes("test")); }
|
### Question:
Configuration { public int getSessionTimeoutInSeconds(String microservice) { final int defaultValue = 30; String p = getStringProperty("30", ROOT + microservice + "." + SESSION_TIMEOUT_IN_SECONDS, ROOT + SESSION_TIMEOUT_IN_SECONDS); try { return Integer.parseInt(p); } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }### Answer:
@Test public void testGetSessionTimeoutInSeconds() { assertNotNull(Configuration.INSTANCE.getSessionTimeoutInSeconds("test")); }
|
### Question:
Configuration { public int getMaxSingleTestWindow() { final int defaultValue = 60000; String p = getStringProperty(Integer.toString(defaultValue), ROOT + FILTER_ISOLATION + FILTER_MAX_SINGLE_TEST_WINDOW); try { int result = Integer.parseInt(p); if (result >= 0) { return result; } return defaultValue; } catch (NumberFormatException e) { return defaultValue; } } private Configuration(); String getRuleStrategyName(String microservice); int getSessionTimeoutInSeconds(String microservice); int getSuccessiveFailedTimes(String microservice); String getRetryHandler(String microservice); boolean isRetryEnabled(String microservice); int getRetryNextServer(String microservice); int getRetrySameServer(String microservice); boolean isIsolationFilterOpen(String microservice); int getErrorThresholdPercentage(String microservice); int getEnableRequestThreshold(String microservice); int getSingleTestTime(String microservice); int getMaxSingleTestWindow(); int getMinIsolationTime(String microservice); Map<String, String> getFlowsplitFilterOptions(String microservice); static String getStringProperty(String defaultValue, String... keys); int getContinuousFailureThreshold(String microservice); static final String ROOT; static final String SERVER_EXPIRED_IN_SECONDS; static final String TIMER_INTERVAL_IN_MILLIS; static final String RULE_STRATEGY_NAME; static final String ROOT_20; static final String RETRY_HANDLER; static final String RETRY_ENABLED; static final String RETRY_ON_NEXT; static final String RETRY_ON_SAME; static final String SESSION_TIMEOUT_IN_SECONDS; static final String SUCCESSIVE_FAILED_TIMES; static final String FILTER_ISOLATION; static final String FILTER_OPEN; static final String FILTER_ERROR_PERCENTAGE; static final String FILTER_ENABLE_REQUEST; static final String FILTER_SINGLE_TEST; static final String FILTER_MAX_SINGLE_TEST_WINDOW; static final String FILTER_MIN_ISOLATION_TIME; static final String FILTER_CONTINUOUS_FAILURE_THRESHOLD; static final String TRANSACTIONCONTROL_OPTIONS_PREFIX_PATTERN; static final Configuration INSTANCE; }### Answer:
@Test public void testGetMaxSingleTestWindow() { assertEquals(60000, Configuration.INSTANCE.getMaxSingleTestWindow()); ArchaiusUtils.setProperty("servicecomb.loadbalance.isolation.maxSingleTestWindow", 5000); assertEquals(5000, Configuration.INSTANCE.getMaxSingleTestWindow()); }
|
### Question:
LoadbalanceHandler implements Handler { protected boolean isFailedResponse(Response resp) { if (resp.isFailed()) { if (InvocationException.class.isInstance(resp.getResult())) { InvocationException e = (InvocationException) resp.getResult(); return e.getStatusCode() == ExceptionFactory.CONSUMER_INNER_STATUS_CODE || e.getStatusCode() == 503; } else { return true; } } else { return false; } } LoadbalanceHandler(DiscoveryTree discoveryTree); LoadbalanceHandler(); @Override void handle(Invocation invocation, AsyncResponse asyncResp); static final String CONTEXT_KEY_SERVER_LIST; static final String SERVICECOMB_SERVER_ENDPOINT; static final boolean supportDefinedEndpoint; }### Answer:
@Test public void testIsFailedResponse() { Assert.assertFalse(handler.isFailedResponse(Response.create(400, "", ""))); Assert.assertFalse(handler.isFailedResponse(Response.create(500, "", ""))); Assert.assertTrue(handler.isFailedResponse(Response.create(490, "", ""))); Assert.assertTrue(handler.isFailedResponse(Response.consumerFailResp(new NullPointerException()))); }
|
### Question:
ExtensionsManager { public static RuleExt createLoadBalancerRule(String microservice) { RuleExt rule = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RULE_STRATEGY_NAME, Configuration.INSTANCE.getRuleStrategyName(microservice))) { rule = factory.createLoadBalancerRule( Configuration.INSTANCE.getRuleStrategyName(microservice)); break; } } if (rule == null) { rule = new RoundRobinRuleExt(); } LOGGER.info("Using load balance rule {} for microservice {}.", rule.getClass().getName(), microservice); return rule; } static void addExtentionsFactory(ExtensionsFactory factory); static RuleExt createLoadBalancerRule(String microservice); static RetryHandler createRetryHandler(String microservice); }### Answer:
@Test public void testRuleName() { System.setProperty("servicecomb.loadbalance.mytest1.strategy.name", "RoundRobin"); System.setProperty("servicecomb.loadbalance.mytest2.strategy.name", "Random"); System.setProperty("servicecomb.loadbalance.mytest3.strategy.name", "WeightedResponse"); System.setProperty("servicecomb.loadbalance.mytest4.strategy.name", "SessionStickiness"); BeansHolder holder = new BeansHolder(); List<ExtensionsFactory> extensionsFactories = new ArrayList<>(); extensionsFactories.add(new RuleNameExtentionsFactory()); extensionsFactories.add(new DefaultRetryExtensionsFactory()); Deencapsulation.setField(holder, "extentionsFactories", extensionsFactories); holder.init(); Assert.assertEquals(RoundRobinRuleExt.class.getName(), ExtensionsManager.createLoadBalancerRule("mytest1").getClass().getName()); Assert.assertEquals(RandomRuleExt.class.getName(), ExtensionsManager.createLoadBalancerRule("mytest2").getClass().getName()); Assert.assertEquals(WeightedResponseTimeRuleExt.class.getName(), ExtensionsManager.createLoadBalancerRule("mytest3").getClass().getName()); Assert.assertEquals(SessionStickinessRule.class.getName(), ExtensionsManager.createLoadBalancerRule("mytest4").getClass().getName()); System.getProperties().remove("servicecomb.loadbalance.mytest1.strategy.name"); System.getProperties().remove("servicecomb.loadbalance.mytest2.strategy.name"); System.getProperties().remove("servicecomb.loadbalance.mytest3.strategy.name"); System.getProperties().remove("servicecomb.loadbalance.mytest4.strategy.name"); }
|
### Question:
ExtensionsManager { public static RetryHandler createRetryHandler(String microservice) { RetryHandler handler = null; for (ExtensionsFactory factory : extentionFactories) { if (factory.isSupport(Configuration.RETRY_HANDLER, Configuration.INSTANCE.getRetryHandler(microservice))) { handler = factory.createRetryHandler(Configuration.INSTANCE.getRetryHandler(microservice), microservice); break; } } LOGGER.debug("Using retry handler {} for microservice {}.", handler.getClass().getName(), microservice); return handler; } static void addExtentionsFactory(ExtensionsFactory factory); static RuleExt createLoadBalancerRule(String microservice); static RetryHandler createRetryHandler(String microservice); }### Answer:
@Test public void testRuleClassName() { BeansHolder holder = new BeansHolder(); List<ExtensionsFactory> extensionsFactories = new ArrayList<>(); extensionsFactories.add(new RuleNameExtentionsFactory()); extensionsFactories.add(new DefaultRetryExtensionsFactory()); Deencapsulation.setField(holder, "extentionsFactories", extensionsFactories); holder.init(); RetryHandler retryHandler = ExtensionsManager.createRetryHandler("mytest1"); Assert.assertTrue(DefaultLoadBalancerRetryHandler.class.isInstance(retryHandler)); Assert.assertFalse(retryHandler.isRetriableException(new InvocationException(400, "", ""), false)); Assert.assertFalse(retryHandler.isRetriableException(new InvocationException(400, "", ""), true)); Assert.assertTrue(retryHandler.isRetriableException(new InvocationException(503, "", ""), true)); Assert.assertTrue(retryHandler.isRetriableException(new ConnectException(), false)); Assert.assertTrue(retryHandler.isRetriableException(new ConnectException(), true)); Assert.assertTrue(retryHandler.isRetriableException(new SocketTimeoutException(), false)); Assert.assertTrue(retryHandler.isRetriableException(new SocketTimeoutException(), true)); Assert.assertFalse(retryHandler.isRetriableException(new IOException(), true)); }
|
### Question:
RoundRobinRuleExt implements RuleExt { @Override public ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation) { if (servers.isEmpty()) { return null; } int index = Math.abs(counter.getAndIncrement()) % servers.size(); return servers.get(index); } @Override ServiceCombServer choose(List<ServiceCombServer> servers, Invocation invocation); }### Answer:
@Test public void testRoundRobin() { RoundRobinRuleExt rule = new RoundRobinRuleExt(); LoadBalancer loadBalancer = new LoadBalancer(rule, "testService"); List<ServiceCombServer> servers = new ArrayList<>(); Invocation invocation = Mockito.mock(Invocation.class); for (int i = 0; i < 2; i++) { ServiceCombServer server = Mockito.mock(ServiceCombServer.class); Mockito.when(server.toString()).thenReturn("server " + i); servers.add(server); loadBalancer.getLoadBalancerStats().noteResponseTime(server, 1); } AtomicInteger server1 = new AtomicInteger(0); AtomicInteger server2 = new AtomicInteger(0); for (int i = 0; i < 2000; i++) { if (rule.choose(servers, invocation).toString().equals("server 0")) { server1.incrementAndGet(); } else { server2.incrementAndGet(); } } Assert.assertEquals(server1.get(), server2.get()); }
@Test public void testBenchmarkRobin() { RoundRobinRuleExt rule = new RoundRobinRuleExt(); LoadBalancer loadBalancer = new LoadBalancer(rule, "testService"); List<ServiceCombServer> servers = new ArrayList<>(); Invocation invocation = Mockito.mock(Invocation.class); for (int i = 0; i < 100; i++) { ServiceCombServer server = Mockito.mock(ServiceCombServer.class); Mockito.when(server.toString()).thenReturn("server " + i); servers.add(server); loadBalancer.getLoadBalancerStats().noteResponseTime(server, 2); } long begin = System.currentTimeMillis(); for (int i = 0; i < 10000; i++) { rule.choose(servers, invocation); } long taken = System.currentTimeMillis() - begin; System.out.println("taken " + taken); Assert.assertEquals("actual token " + taken, taken < 10 * 5, true); }
|
### Question:
ServiceCombServerStats { public static boolean applyForTryingChance(Invocation invocation) { TryingIsolatedServerMarker marker = globalAllowIsolatedServerTryingFlag.get(); if (marker == null) { return globalAllowIsolatedServerTryingFlag.compareAndSet(null, new TryingIsolatedServerMarker(invocation)); } if (marker.isOutdated()) { return globalAllowIsolatedServerTryingFlag.compareAndSet(marker, new TryingIsolatedServerMarker(invocation)); } return false; } ServiceCombServerStats(); ServiceCombServerStats(Clock clock); static boolean isolatedServerCanTry(); static boolean applyForTryingChance(Invocation invocation); static void checkAndReleaseTryingChance(Invocation invocation); void markIsolated(boolean isolated); void markSuccess(); void markFailure(); long getLastVisitTime(); long getLastActiveTime(); long getCountinuousFailureCount(); long getTotalRequests(); long getSuccessRequests(); long getFailedRequests(); int getSuccessRate(); int getFailedRate(); boolean isIsolated(); }### Answer:
@Test public void testGlobalAllowIsolatedServerTryingFlag_apply_with_null_precondition() { Invocation invocation = new Invocation(); Assert.assertTrue(ServiceCombServerStats.applyForTryingChance(invocation)); Assert.assertSame(invocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); }
@Test public void testGlobalAllowIsolatedServerTryingFlag_apply_with_chance_occupied() { Invocation invocation = new Invocation(); Assert.assertTrue(ServiceCombServerStats.applyForTryingChance(invocation)); Assert.assertSame(invocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); Invocation otherInvocation = new Invocation(); Assert.assertFalse(ServiceCombServerStats.applyForTryingChance(otherInvocation)); Assert.assertSame(invocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); }
@Test public void testGlobalAllowIsolatedServerTryingFlag_apply_with_flag_outdated() { Invocation invocation = new Invocation(); Assert.assertTrue(ServiceCombServerStats.applyForTryingChance(invocation)); Assert.assertSame(invocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().clock = new MockClock(new Holder<>( ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().startTryingTimestamp + 60000 )); Invocation otherInvocation = new Invocation(); Assert.assertTrue(ServiceCombServerStats.applyForTryingChance(otherInvocation)); Assert .assertSame(otherInvocation, ServiceCombServerStats.globalAllowIsolatedServerTryingFlag.get().getInvocation()); }
|
### Question:
ServiceCombServer extends Server { public Endpoint getEndpoint() { return endpoint; } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void testGetEndpoint() { cs.getEndpoint(); assertNotNull(cs.getEndpoint()); }
|
### Question:
ServiceCombServer extends Server { public boolean equals(Object o) { if (o instanceof ServiceCombServer) { return this.instance.getInstanceId().equals(((ServiceCombServer) o).instance.getInstanceId()); } else { return false; } } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void testEqualsMethod() { Assert.assertFalse(cs.equals((Object) "abcd")); MicroserviceInstance instance1 = new MicroserviceInstance(); instance1.setInstanceId("1234"); ServiceCombServer other = new ServiceCombServer(transport, new CacheEndpoint("1234", instance1)); Assert.assertFalse(cs.equals(other)); MicroserviceInstance instance2 = new MicroserviceInstance(); instance2.setInstanceId("123456"); other = new ServiceCombServer(transport, new CacheEndpoint("abcd", instance2)); Assert.assertTrue(cs.equals(other)); }
|
### Question:
ServiceCombServer extends Server { public String toString() { return endpoint.getEndpoint(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void testToStringMethod() { cs.toString(); assertNotNull(cs.toString()); }
|
### Question:
ServiceCombServer extends Server { public String getHost() { return endpoint.getEndpoint(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void testGetHost() { cs.getHost(); assertNotNull(cs.getHost()); }
|
### Question:
ServiceCombServer extends Server { public int hashCode() { return this.instance.getInstanceId().hashCode(); } @VisibleForTesting ServiceCombServer(Endpoint endpoint, MicroserviceInstance instance); ServiceCombServer(Transport transport, CacheEndpoint cacheEndpoint); Endpoint getEndpoint(); MicroserviceInstance getInstance(); String toString(); String getHost(); boolean equals(Object o); int hashCode(); }### Answer:
@Test public void testHashCodeMethod() { cs.hashCode(); assertNotNull(cs.hashCode()); }
|
### Question:
ProviderQpsFlowControlHandler implements Handler { private boolean isLimitNewRequest(QpsStrategy qpsStrategy, AsyncResponse asyncResp) { if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.producerFail(new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return true; } else { return false; } } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }### Answer:
@Test public void testQpsController() { AbstractQpsStrategy qpsStrategy = new FixedWindowStrategy(); qpsStrategy.setKey("abc"); qpsStrategy.setQpsLimit(100L); assertFalse(qpsStrategy.isLimitNewRequest()); qpsStrategy.setQpsLimit(1L); assertTrue(qpsStrategy.isLimitNewRequest()); }
|
### Question:
OperationPerfGroup { public void addOperationPerf(OperationPerf operationPerf) { operationPerfs.add(operationPerf); if (summary == null) { summary = new OperationPerf(); summary.setOperation(""); } summary.add(operationPerf); } OperationPerfGroup(String transport, String status); String getTransport(); String getStatus(); List<OperationPerf> getOperationPerfs(); OperationPerf getSummary(); void addOperationPerf(OperationPerf operationPerf); }### Answer:
@Test public void addOperationPerf() { OperationPerf opPerf = Utils.createOperationPerf(op); group.addOperationPerf(opPerf); group.addOperationPerf(opPerf); Assert.assertThat(group.getOperationPerfs(), Matchers.contains(opPerf, opPerf)); OperationPerf summary = group.getSummary(); PerfInfo perfInfo = summary.findStage(MeterInvocationConst.STAGE_TOTAL); Assert.assertEquals(20, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); perfInfo = summary.findStage(MeterInvocationConst.STAGE_EXECUTION); Assert.assertEquals(20, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); }
|
### Question:
ConsumerQpsFlowControlHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { if (!Config.INSTANCE.isConsumerEnabled()) { invocation.next(asyncResp); return; } QpsStrategy qpsStrategy = qpsControllerMgr.getOrCreate(invocation.getMicroserviceName(), invocation); if (qpsStrategy.isLimitNewRequest()) { CommonExceptionData errorData = new CommonExceptionData("rejected by qps flowcontrol"); asyncResp.consumerFail( new InvocationException(QpsConst.TOO_MANY_REQUESTS_STATUS, errorData)); return; } invocation.next(asyncResp); } @Override void handle(Invocation invocation, AsyncResponse asyncResp); }### Answer:
@Test public void testHandle() throws Exception { String key = "svc.schema.opr"; AbstractQpsStrategy qpsStrategy = new FixedWindowStrategy(); qpsStrategy.setKey("key"); qpsStrategy.setQpsLimit(12L); Mockito.when(invocation.getOperationMeta()).thenReturn(operationMeta); Mockito.when(operationMeta.getSchemaQualifiedName()).thenReturn("schema.opr"); Mockito.when(invocation.getSchemaId()).thenReturn("schema"); Mockito.when(invocation.getMicroserviceName()).thenReturn("svc"); setQpsController(key, qpsStrategy); new MockUp<FixedWindowStrategy>() { @Mock public boolean isLimitNewRequest() { return true; } }; new MockUp<QpsControllerManager>() { @Mock protected QpsStrategy create(String qualifiedNameKey) { return qpsStrategy; } }; handler.handle(invocation, asyncResp); ArgumentCaptor<InvocationException> captor = ArgumentCaptor.forClass(InvocationException.class); Mockito.verify(asyncResp).consumerFail(captor.capture()); InvocationException invocationException = captor.getValue(); assertEquals(QpsConst.TOO_MANY_REQUESTS_STATUS, invocationException.getStatus()); assertEquals("rejected by qps flowcontrol", ((CommonExceptionData) invocationException.getErrorData()).getMessage()); }
@Test public void testHandleIsLimitNewRequestAsFalse() throws Exception { String key = "service.schema.id"; AbstractQpsStrategy qpsStrategy = new FixedWindowStrategy(); qpsStrategy.setKey("service"); qpsStrategy.setQpsLimit(12L); Mockito.when(invocation.getMicroserviceName()).thenReturn("service"); Mockito.when(invocation.getOperationMeta()).thenReturn(operationMeta); Mockito.when(operationMeta.getSchemaQualifiedName()).thenReturn("schema.id"); setQpsController(key, qpsStrategy); new MockUp<QpsStrategy>() { @Mock public boolean isLimitNewRequest() { return false; } }; new MockUp<QpsControllerManager>() { @Mock protected QpsStrategy create(String qualifiedNameKey) { return qpsStrategy; } }; handler.handle(invocation, asyncResp); Mockito.verify(invocation).next(asyncResp); }
|
### Question:
PerfInfo { @Override public String toString() { return "PerfInfo [tps=" + tps + ", msTotalTime=" + msTotalTime + ", msLatency=" + calcMsLatency() + ", msMaxLatency=" + msMaxLatency + "]"; } double getTps(); void setTps(double tps); double getMsTotalTime(); void setMsTotalTime(double msTotalTime); double getMsMaxLatency(); void setMsMaxLatency(double msMaxLatency); void add(PerfInfo other); double calcMsLatency(); @Override String toString(); }### Answer:
@Test public void testToString() { PerfInfo perf = new PerfInfo(); perf.setTps(10); perf.setMsTotalTime(10); perf.setMsMaxLatency(100); Assert.assertEquals("PerfInfo [tps=10.0, msTotalTime=10.0, msLatency=1.0, msMaxLatency=100.0]", perf.toString()); }
|
### Question:
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> resumeWithFallback() { Throwable cause = getFailedExecutionException(); Observable<Response> observable = Observable.create(f -> { try { f.onNext(FallbackPolicyManager.getFallbackResponse(type, cause, invocation)); f.onCompleted(); } catch (Exception e) { LOG.warn("fallback failed due to:" + e.getMessage()); throw e; } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }### Answer:
@Test public void testResumeWithFallbackProvider() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); Observable<Response> observe = bizkeeperCommand.resumeWithFallback(); Assert.assertNotNull(observe); }
@Test public void testResumeWithFallbackConsumer() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); Observable<Response> observe = bizkeeperCommand.resumeWithFallback(); Assert.assertNotNull(observe); }
|
### Question:
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected Observable<Response> construct() { Observable<Response> observable = Observable.create(f -> { try { invocation.next(resp -> { if (isFailedResponse(resp)) { LOG.warn("bizkeeper command {} failed due to {}", invocation.getInvocationQualifiedName(), resp.getResult()); f.onError(resp.getResult()); FallbackPolicyManager.record(type, invocation, resp, false); } else { f.onNext(resp); f.onCompleted(); FallbackPolicyManager.record(type, invocation, resp, true); } }); } catch (Exception e) { LOG.warn("bizkeeper command {} execute failed due to {}", invocation.getInvocationQualifiedName(), e.getClass().getName()); f.onError(e); } }); return observable; } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }### Answer:
@Test public void testConstructProvider() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); Observable<Response> response = bizkeeperCommand.construct(); Assert.assertNotNull(response); }
@Test public void testConstructConsumer() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); Observable<Response> response = bizkeeperCommand.construct(); Assert.assertNotNull(response); }
|
### Question:
BizkeeperCommand extends HystrixObservableCommand<Response> { @Override protected String getCacheKey() { if (HystrixRequestContext.isCurrentThreadInitialized()) { StringBuilder sb = new StringBuilder(); sb.append(this.getCommandGroup().name()); sb.append("-"); sb.append(this.getCommandKey().name()); return sb.toString(); } else { return super.getCacheKey(); } } protected BizkeeperCommand(String type, Invocation invocation, HystrixObservableCommand.Setter setter); }### Answer:
@Test public void testGetCacheKeyWithContextInitializedProvider() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ProviderBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); HystrixRequestContext.initializeContext(); String cacheKey = bizkeeperCommand.getCacheKey(); Assert.assertNotNull(cacheKey); }
@Test public void testGetCacheKeyWithContextInitializedConsumer() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); BizkeeperCommand bizkeeperCommand = new ConsumerBizkeeperCommand("groupname", invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey("groupname", invocation)) .andCommandKey(CommandKey.toHystrixCommandKey("groupname", invocation)) .andCommandPropertiesDefaults(setter)); HystrixRequestContext.initializeContext(); String cacheKey = bizkeeperCommand.getCacheKey(); Assert.assertNotNull(cacheKey); }
|
### Question:
OperationPerf { public void add(OperationPerf operationPerf) { operationPerf.stages.forEach((key, value) -> { PerfInfo perfInfo = stages.computeIfAbsent(key, n -> new PerfInfo()); perfInfo.add(value); }); if (operationPerf.getLatencyDistribution() == null) { return; } if (latencyDistribution == null) { latencyDistribution = new Integer[operationPerf.getLatencyDistribution().length]; Arrays.fill(latencyDistribution, 0); } for (int idx = 0; idx < operationPerf.getLatencyDistribution().length; idx++) { latencyDistribution[idx] += operationPerf.getLatencyDistribution()[idx]; } } String getOperation(); void setOperation(String operation); Map<String, PerfInfo> getStages(); Integer[] getLatencyDistribution(); void setLatencyDistribution(Integer[] latencyDistribution); void setStages(Map<String, PerfInfo> stages); PerfInfo findStage(String stage); void add(OperationPerf operationPerf); }### Answer:
@Test public void add() { Assert.assertTrue(opPerf.getStages().isEmpty()); OperationPerf otherOpPerf = Utils.createOperationPerf(op); opPerf.add(otherOpPerf); Assert.assertEquals(op, otherOpPerf.getOperation()); PerfInfo perfInfo = opPerf.findStage(MeterInvocationConst.STAGE_TOTAL); Assert.assertEquals(10, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); perfInfo = opPerf.findStage(MeterInvocationConst.STAGE_EXECUTION); Assert.assertEquals(10, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); }
|
### Question:
CommandKey { public static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation) { return CustomizeCommandGroupKey.asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName(), invocation); } private CommandKey(); static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation); static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation); }### Answer:
@Test public void testToHystrixCommandGroupKey() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); Assert.assertNotNull(invocation); HystrixCommandGroupKey hystrixCommandGroupKey = CommandKey.toHystrixCommandGroupKey("groupname", invocation); Assert.assertNotNull(hystrixCommandGroupKey); }
|
### Question:
CommandKey { public static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation) { return HystrixCommandKey.Factory .asKey(type + "." + invocation.getOperationMeta().getMicroserviceQualifiedName()); } private CommandKey(); static HystrixCommandGroupKey toHystrixCommandGroupKey(String type, Invocation invocation); static HystrixCommandKey toHystrixCommandKey(String type, Invocation invocation); }### Answer:
@Test public void testToHystrixCommandKey() { Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); Assert.assertNotNull(invocation); HystrixCommandKey hystrixCommandGroupKey = CommandKey.toHystrixCommandKey("groupname", invocation); Assert.assertNotNull(hystrixCommandGroupKey); }
|
### Question:
ConsumerBizkeeperHandler extends BizkeeperHandler { @Override protected BizkeeperCommand createBizkeeperCommand(Invocation invocation) { HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false); setCommonProperties(invocation, setter); BizkeeperCommand command = new ConsumerBizkeeperCommand(groupname, invocation, HystrixObservableCommand.Setter .withGroupKey(CommandKey.toHystrixCommandGroupKey(groupname, invocation)) .andCommandKey(CommandKey.toHystrixCommandKey(groupname, invocation)) .andCommandPropertiesDefaults(setter)); return command; } ConsumerBizkeeperHandler(); }### Answer:
@Test public void testCreateBizkeeperCommand() { HystrixPlugins.reset(); ConsumerBizkeeperHandler consumerBizkeeperHandler = new ConsumerBizkeeperHandler(); Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceQualifiedName()).thenReturn("test1"); CommandKey.toHystrixCommandGroupKey("groupname", invocation); CommandKey.toHystrixCommandKey("groupname", invocation); BizkeeperCommand command = consumerBizkeeperHandler.createBizkeeperCommand(invocation); Assert.assertNotNull(command); }
|
### Question:
BizkeeperRequestContext { public static BizkeeperRequestContext initializeContext() { return new BizkeeperRequestContext(HystrixRequestContext.initializeContext()); } private BizkeeperRequestContext(HystrixRequestContext context); static BizkeeperRequestContext initializeContext(); void shutdown(); }### Answer:
@Test public void testInitializeContext() { BizkeeperRequestContext bizkeeperRequestContext = BizkeeperRequestContext.initializeContext(); Assert.assertNotNull(bizkeeperRequestContext); }
|
### Question:
BizkeeperRequestContext { public void shutdown() { this.context.shutdown(); } private BizkeeperRequestContext(HystrixRequestContext context); static BizkeeperRequestContext initializeContext(); void shutdown(); }### Answer:
@Test public void testShutdown() { BizkeeperRequestContext bizkeeperRequestContext = BizkeeperRequestContext.initializeContext(); boolean validAssert; try { bizkeeperRequestContext.shutdown(); validAssert = true; } catch (Exception e) { validAssert = false; } Assert.assertTrue(validAssert); }
|
### Question:
BizkeeperHandler implements Handler { protected void setCommonProperties(Invocation invocation, HystrixCommandProperties.Setter setter) { } BizkeeperHandler(String groupname); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }### Answer:
@Test public void testSetCommonProperties() { boolean validAssert; try { validAssert = true; HystrixPlugins.reset(); HystrixCommandProperties.Setter setter = Mockito.mock(HystrixCommandProperties.Setter.class); bizkeeperHandler.setCommonProperties(invocation, setter); } catch (Exception e) { validAssert = false; } Assert.assertTrue(validAssert); }
|
### Question:
DefaultLogPublisher implements MetricsInitializer { @Override public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { if (!DynamicPropertyFactory.getInstance() .getBooleanProperty(ENABLED, false) .get()) { return; } initLatencyDistribution(); eventBus.register(this); } @Override void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Subscribe void onPolledEvent(PolledEvent event); static final String ENABLED; static final String ENDPOINTS_CLIENT_DETAIL_ENABLED; }### Answer:
@Test public void init_enabled_default() { Holder<Boolean> registered = new Holder<>(false); new MockUp<EventBus>(eventBus) { @Mock void register(Object object) { registered.value = true; } }; publisher.init(globalRegistry, eventBus, new MetricsBootstrapConfig()); Assert.assertFalse(registered.value); }
@Test public void init_enabled_true() { Holder<Boolean> registered = new Holder<>(); new MockUp<EventBus>(eventBus) { @Mock void register(Object object) { registered.value = true; } }; ArchaiusUtils.setProperty(DefaultLogPublisher.ENABLED, true); publisher.init(globalRegistry, eventBus, new MetricsBootstrapConfig()); Assert.assertTrue(registered.value); }
@Test public void init_enabled_false() { Holder<Boolean> registered = new Holder<>(); new MockUp<EventBus>(eventBus) { @Mock void register(Object object) { registered.value = true; } }; ArchaiusUtils.setProperty(DefaultLogPublisher.ENABLED, false); publisher.init(globalRegistry, eventBus, new MetricsBootstrapConfig()); Assert.assertNull(registered.value); }
|
### Question:
Configuration { private Configuration() { } private Configuration(); int getIsolationTimeoutInMilliseconds(String type, String microserviceName,
String qualifiedOperationName); boolean getIsolationTimeoutEnabled(String type, String microserviceName,
String qualifiedOperationName); int getIsolationMaxConcurrentRequests(String type, String microserviceName,
String qualifiedOperationName); boolean isCircuitBreakerEnabled(String type, String microserviceName, String qualifiedOperationName); boolean isCircuitBreakerForceOpen(String type, String microserviceName, String qualifiedOperationName); boolean isCircuitBreakerForceClosed(String type, String microserviceName, String qualifiedOperationName); int getCircuitBreakerSleepWindowInMilliseconds(String type, String microserviceName,
String qualifiedOperationName); int getCircuitBreakerRequestVolumeThreshold(String type, String microserviceName,
String qualifiedOperationName); int getCircuitBreakerErrorThresholdPercentage(String type, String microserviceName,
String qualifiedOperationName); boolean isFallbackEnabled(String type, String microserviceName, String qualifiedOperationName); boolean isFallbackForce(String type, String microserviceName, String qualifiedOperationName); int getFallbackMaxConcurrentRequests(String type, String microserviceName, String qualifiedOperationName); String getFallbackPolicyPolicy(String type, String microserviceName, String qualifiedOperationName); static final String FALLBACKPOLICY_POLICY_THROW; static final String FALLBACKPOLICY_POLICY_RETURN; static final Configuration INSTANCE; }### Answer:
@Test public void testConfiguration() { assertNotNull(Configuration.INSTANCE); assertEquals("returnnull", Configuration.FALLBACKPOLICY_POLICY_RETURN); assertEquals("throwexception", Configuration.FALLBACKPOLICY_POLICY_THROW); Configuration c = Configuration.INSTANCE; Invocation invocation = Mockito.mock(Invocation.class); String test2 = invocation.getMicroserviceName(); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceName()).thenReturn("testqualify"); int res = c.getIsolationTimeoutInMilliseconds("groupname", test2, "testqualify"); assertEquals(30000, res); boolean b1 = c.getIsolationTimeoutEnabled("groupname", test2, "testqualify"); assertFalse(b1); int res1 = c.getIsolationMaxConcurrentRequests("groupname", test2, "testqualify"); assertEquals(1000, res1); boolean b2 = c.isCircuitBreakerEnabled("groupname", test2, "testqualify"); assertTrue(b2); String str = c.getFallbackPolicyPolicy("groupname", test2, "testqualify"); assertEquals(null, str); assertFalse(c.isCircuitBreakerForceOpen("groupname", test2, "testqualify")); assertFalse(c.isCircuitBreakerForceClosed("groupname", test2, "testqualify")); assertEquals(15000, c.getCircuitBreakerSleepWindowInMilliseconds("groupname", test2, "testqualify")); assertEquals(20, c.getCircuitBreakerRequestVolumeThreshold("groupname", test2, "testqualify")); assertEquals(50, c.getCircuitBreakerErrorThresholdPercentage("groupname", test2, "testqualify")); assertTrue(c.isFallbackEnabled("groupname", test2, "testqualify")); }
|
### Question:
BizkeeperExceptionUtils extends ExceptionUtils { public static CseException createBizkeeperException(String code, Throwable cause, Object... args) { String msg = String.format(ERROR_DESC_MGR.ensureFindValue(code), args); return new CseException(code, msg, cause); } private BizkeeperExceptionUtils(); static CseException createBizkeeperException(String code, Throwable cause, Object... args); static final String SERVICECOMB_BIZKEEPER_FALLBACK; }### Answer:
@Test public void testCreateBizkeeperException() { Assert.assertEquals("servicecomb.bizkeeper.fallback", BizkeeperExceptionUtils.SERVICECOMB_BIZKEEPER_FALLBACK); CseException cseException = BizkeeperExceptionUtils.createBizkeeperException("servicecomb.bizkeeper.fallback", new Throwable(), "ARGS"); Assert.assertNotNull(cseException); }
|
### Question:
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { public static HystrixPropertiesStrategyExt getInstance() { return INSTANCE; } private HystrixPropertiesStrategyExt(); static HystrixPropertiesStrategyExt getInstance(); @Override HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder); }### Answer:
@Test public void testGetCommandPropertiesCacheKey() { assertNotNull(HystrixPropertiesStrategyExt.getInstance()); HystrixPropertiesStrategyExt hps = HystrixPropertiesStrategyExt.getInstance(); HystrixCommandKey commandKey = Mockito.mock(HystrixCommandKey.class); Invocation invocation = Mockito.mock(Invocation.class); Mockito.when(invocation.getOperationMeta()).thenReturn(Mockito.mock(OperationMeta.class)); Mockito.when(invocation.getOperationMeta().getMicroserviceName()).thenReturn("testqualify"); HystrixCommandProperties.Setter setter = HystrixCommandProperties.Setter() .withRequestCacheEnabled(true) .withRequestLogEnabled(false) .withFallbackIsolationSemaphoreMaxConcurrentRequests( Configuration.INSTANCE.getFallbackMaxConcurrentRequests("groupname", "testing", invocation.getOperationMeta().getMicroserviceQualifiedName())); String str1 = hps.getCommandPropertiesCacheKey(commandKey, setter); Assert.assertNull(str1); }
|
### Question:
HystrixPropertiesStrategyExt extends HystrixPropertiesStrategy { @Override public HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder) { HystrixCommandProperties commandProperties = commandPropertiesMap.get(commandKey.name()); if (commandProperties == null) { commandProperties = new HystrixCommandPropertiesExt(commandKey, builder); commandPropertiesMap.putIfAbsent(commandKey.name(), commandProperties); } return commandProperties; } private HystrixPropertiesStrategyExt(); static HystrixPropertiesStrategyExt getInstance(); @Override HystrixCommandProperties getCommandProperties(HystrixCommandKey commandKey, Setter builder); }### Answer:
@Test public void testgetCommandProperties() { HystrixCommandKey commandKey = Mockito.mock(HystrixCommandKey.class); Mockito.when(commandKey.name()) .thenReturn("provider.HystrixPropertiesStrategyExtTest.testgetCommandProperties"); HystrixCommandProperties commandPro = HystrixPropertiesStrategyExt.getInstance() .getCommandProperties(commandKey, HystrixCommandProperties.Setter()); Assert.assertTrue(commandPro.circuitBreakerEnabled().get()); Assert.assertEquals(Integer.valueOf(50), commandPro.circuitBreakerErrorThresholdPercentage().get()); Assert.assertFalse(commandPro.circuitBreakerForceClosed().get()); Assert.assertFalse(commandPro.circuitBreakerForceOpen().get()); Assert.assertEquals(Integer.valueOf(20), commandPro.circuitBreakerRequestVolumeThreshold().get()); Assert.assertEquals(Integer.valueOf(15000), commandPro.circuitBreakerSleepWindowInMilliseconds().get()); Assert.assertEquals(Integer.valueOf(1000), commandPro.executionIsolationSemaphoreMaxConcurrentRequests().get()); Assert.assertTrue(commandPro.executionIsolationThreadInterruptOnTimeout().get()); Assert.assertEquals(null, commandPro.executionIsolationThreadPoolKeyOverride().get()); Assert.assertEquals(Integer.valueOf(30000), commandPro.executionTimeoutInMilliseconds().get()); Assert.assertFalse(commandPro.executionTimeoutEnabled().get()); Assert.assertEquals(Integer.valueOf(10), commandPro.fallbackIsolationSemaphoreMaxConcurrentRequests().get()); Assert.assertTrue(commandPro.fallbackEnabled().get()); Assert.assertEquals(Integer.valueOf(100), commandPro.metricsRollingPercentileBucketSize().get()); Assert.assertFalse(commandPro.metricsRollingPercentileEnabled().get()); }
|
### Question:
CircutBreakerEventNotifier extends HystrixEventNotifier { @Override public void markEvent(HystrixEventType eventType, HystrixCommandKey key) { String keyName = key.name(); AtomicBoolean flag = circuitFlag.computeIfAbsent(keyName, k -> new AtomicBoolean()); switch (eventType) { case SHORT_CIRCUITED: if (flag.compareAndSet(false, true)) { eventBus.post(new CircutBreakerEvent(key, Type.OPEN)); } break; case SUCCESS: if (flag.compareAndSet(true, false)) { eventBus.post(new CircutBreakerEvent(key, Type.CLOSE)); } break; default: break; } } @Override void markEvent(HystrixEventType eventType, HystrixCommandKey key); }### Answer:
@Test public void testMarkEvent() { Mockito.when(commandKey.name()).thenReturn("Consumer.springmvc.springmvcHello.sayHi"); new Expectations(HystrixCommandMetrics.class) { { HystrixCommandMetrics.getInstance(commandKey); result = null; } }; circutBreakerEventNotifier.markEvent(HystrixEventType.SHORT_CIRCUITED, commandKey); Assert.assertEquals(1, taskList.size()); circutBreakerEventNotifier.markEvent(HystrixEventType.SUCCESS, commandKey); Assert.assertEquals(2, taskList.size()); }
|
### Question:
DtmProviderHandler implements Handler { @Override public void handle(Invocation invocation, AsyncResponse asyncResp) throws Exception { try { if (dtmContextImMethod != null) { String traceId = invocation.getContext().get(Const.TRACE_ID_NAME); invocation.getContext().put(DTM_TRACE_ID_KEY, traceId); dtmContextImMethod.invoke(null, invocation.getContext()); } } catch (Throwable e) { LOG.warn("Failed to execute method DTMContext#{}, please check", DtmConfig.DTM_IMPORT_METHOD, e); } invocation.next(asyncResp); } DtmProviderHandler(); @Override void handle(Invocation invocation, AsyncResponse asyncResp); }### Answer:
@Test public void testHandler(@Mocked Invocation invocation) throws Exception { DtmProviderHandler providerHandler = new DtmProviderHandler(); providerHandler.init(null, null); Map<String, String> context = new HashMap<>(); new Expectations() {{ invocation.getContext(); result = context; }}; String expectTxId = "dtm-tx-id"; String expectTraceId = "dtm-trace-id"; context.put(DTMContext.GLOBAL_TX_ID_KEY, expectTxId); context.put(Const.TRACE_ID_NAME, expectTraceId); Assert.assertEquals("", DTMContext.TRACE_ID); Assert.assertEquals("", DTMContext.GLOBAL_TX_ID); providerHandler.handle(invocation, null); Assert.assertEquals(expectTraceId, DTMContext.TRACE_ID); Assert.assertEquals(expectTxId, DTMContext.GLOBAL_TX_ID); }
|
### Question:
CasEnvConfig { public Map<String, String> getNonEmptyProperties() { return properties.entrySet().stream().filter(entry -> StringUtils.isNotEmpty(entry.getValue())) .collect(Collectors.toMap(Entry::getKey, Entry::getValue)); } private CasEnvConfig(); Map<String, String> getNonEmptyProperties(); static final CasEnvConfig INSTANCE; }### Answer:
@Test public void testConfig() { CasEnvConfig instance = CasEnvConfig.INSTANCE; assertEquals(2, instance.getNonEmptyProperties().size()); assertEquals("application-id", instance.getNonEmptyProperties().get("CAS_APPLICATION_ID")); assertEquals("env-id", instance.getNonEmptyProperties().get("CAS_ENVIRONMENT_ID")); }
|
### Question:
KieClient { public String putKeyValue(String key, KVBody kvBody) { try { ObjectMapper mapper = new ObjectMapper(); HttpResponse response = httpClient.putHttpRequest("/kie/kv/" + key, null, mapper.writeValueAsString(kvBody)); if (response.getStatusCode() == HttpStatus.SC_OK) { return response.getContent(); } else { LOGGER.error("create keyValue fails, responseStatusCode={}, responseMessage={}, responseContent{}", response.getStatusCode(), response.getMessage(), response.getContent()); } } catch (IOException e) { LOGGER.error("create keyValue fails", e); } return null; } KieClient(); KieClient(String host, int port, String projectName); KieClient(KieRawClient serviceCenterRawClient); String putKeyValue(String key, KVBody kvBody); List<KVResponse> getValueOfKey(String key); List<KVResponse> searchKeyValueByLabels(Map<String, String> labels); void deleteKeyValue(KVDoc kvDoc); }### Answer:
@Test public void putKeyValue() throws IOException { KieRawClient kieRawClient = Mockito.mock(KieRawClient.class); KVBody kvBody = new KVBody(); kvBody.setValue("test"); kvBody.setValueType("string"); Map<String, String> labels = new HashMap<>(); labels.put("app1", "111"); kvBody.setLabels(labels); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("OK"); String responseContext = "{\n" + " \"_id\": \"5db0213bb927bafaf707e06a\",\n" + " \"label_id\": \"5db0039bb927bafaf707e037\",\n" + " \"key\": \"testKey\",\n" + " \"value\": \"testValue\",\n" + " \"value_type\": \"string\",\n" + " \"labels\": {\n" + " \"app1\": \"111\"\n" + " },\n" + " \"domain\": \"default\",\n" + " \"revision\": 10\n" + "}"; httpResponse.setContent(responseContext); ObjectMapper mapper = new ObjectMapper(); Mockito.when(kieRawClient.putHttpRequest("/kie/kv/test1", null, mapper.writeValueAsString(kvBody))) .thenReturn(httpResponse); KieClient kieClient = new KieClient(kieRawClient); String kvResponses = kieClient.putKeyValue("test1", kvBody); Assert.assertNotNull(kvResponses); }
|
### Question:
KieClient { public void deleteKeyValue(KVDoc kvDoc) { try { HttpResponse response = httpClient.deleteHttpRequest("/kie/kv/?kvID=" + kvDoc.getId(), null, null); if (response.getStatusCode() == HttpStatus.SC_NO_CONTENT) { LOGGER.info("Delete keyValue success"); } else { LOGGER.error("delete keyValue fails, responseStatusCode={}, responseMessage={}, responseContent{}", response.getStatusCode(), response.getMessage(), response.getContent()); } } catch (IOException e) { LOGGER.error("delete keyValue fails", e); } } KieClient(); KieClient(String host, int port, String projectName); KieClient(KieRawClient serviceCenterRawClient); String putKeyValue(String key, KVBody kvBody); List<KVResponse> getValueOfKey(String key); List<KVResponse> searchKeyValueByLabels(Map<String, String> labels); void deleteKeyValue(KVDoc kvDoc); }### Answer:
@Test public void deleteKeyValue() throws IOException { KieRawClient kieRawClient = Mockito.mock(KieRawClient.class); KVDoc kvDoc = new KVDoc(); kvDoc.setId("111"); kvDoc.setKey("test"); kvDoc.setValue("testValue"); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(204); httpResponse.setMessage("OK"); Mockito.when(kieRawClient.deleteHttpRequest("/kie/kv/?kvID=" + kvDoc.getId(), null, null)) .thenReturn(httpResponse); KieClient kieClient = new KieClient(kieRawClient); kieClient.deleteKeyValue(kvDoc); }
|
### Question:
ServiceCenterClient implements ServiceCenterOperation { @Override public RegisteredMicroserviceResponse registerMicroservice(Microservice microservice) { try { CreateMicroserviceRequest request = new CreateMicroserviceRequest(); request.setService(microservice); HttpResponse response = httpClient .postHttpRequest("/registry/microservices", null, HttpUtils.serialize(request)); if (response.getStatusCode() == HttpStatus.SC_OK) { return HttpUtils.deserialize(response.getContent(), RegisteredMicroserviceResponse.class); } else { throw new OperationException( "register service fails, statusCode = " + response.getStatusCode() + "; message = " + response .getMessage() + "; content = " + response.getContent()); } } catch (IOException e) { throw new OperationException( "register service fails", e); } } ServiceCenterClient(ServiceCenterRawClient httpClient); ServiceCenterClient(AddressManager addressManager, SSLProperties sslProperties,
AKSKProperties akskProperties,
String tenantName,
Map<String, String> extraGlobalHeaders); @Override MicroserviceInstancesResponse getServiceCenterInstances(); @Override RegisteredMicroserviceResponse registerMicroservice(Microservice microservice); @Override MicroservicesResponse getMicroserviceList(); @Override RegisteredMicroserviceResponse queryServiceId(Microservice microservice); @Override Microservice getMicroserviceByServiceId(String serviceId); @Override RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance); @Override FindMicroserviceInstancesResponse findMicroserviceInstance(String consumerId, String appId, String serviceName,
String versionRule,
String revision); @Override MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId); @Override MicroserviceInstance getMicroserviceInstance(String serviceId, String instanceId); void deleteMicroserviceInstance(String serviceId, String instanceId); @Override boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId,
MicroserviceInstanceStatus status); void sendHeartBeats(HeartbeatsRequest heartbeatsRequest); @Override boolean sendHeartBeat(String serviceId, String instanceId); List<SchemaInfo> getServiceSchemasList(String serviceId); String getServiceSchemaContext(String serviceId, String schemaId); @Override boolean registerSchema(String serviceId, String schemaId, CreateSchemaRequest schema); @Override boolean updateServiceSchemaContext(String serviceId, SchemaInfo schemaInfo); @Override boolean batchUpdateServiceSchemaContext(String serviceId, ModifySchemasRequest modifySchemasRequest); }### Answer:
@Test public void TestRegistryService() throws IOException { ServiceCenterRawClient serviceCenterRawClient = Mockito.mock(ServiceCenterRawClient.class); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("ok"); httpResponse.setContent("{\"serviceId\": \"111111\"}"); Microservice microservice = new Microservice(); microservice.setServiceName("Test"); ObjectMapper objectMapper = new ObjectMapper(); objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true); Mockito.when(serviceCenterRawClient .postHttpRequest("/registry/microservices", null, objectMapper.writeValueAsString(microservice))) .thenReturn(httpResponse); ServiceCenterClient serviceCenterClient = new ServiceCenterClient(serviceCenterRawClient); RegisteredMicroserviceResponse actualResponse = serviceCenterClient.registerMicroservice(microservice); Assert.assertNotNull(actualResponse); Assert.assertEquals("111111", actualResponse.getServiceId()); }
|
### Question:
ServiceCenterClient implements ServiceCenterOperation { @Override public MicroservicesResponse getMicroserviceList() { try { HttpResponse response = httpClient.getHttpRequest("/registry/microservices", null, null); if (response.getStatusCode() == HttpStatus.SC_OK) { return HttpUtils.deserialize(response.getContent(), MicroservicesResponse.class); } else { throw new OperationException( "get service List fails, statusCode = " + response.getStatusCode() + "; message = " + response .getMessage() + "; content = " + response.getContent()); } } catch (IOException e) { throw new OperationException( "get service List fails", e); } } ServiceCenterClient(ServiceCenterRawClient httpClient); ServiceCenterClient(AddressManager addressManager, SSLProperties sslProperties,
AKSKProperties akskProperties,
String tenantName,
Map<String, String> extraGlobalHeaders); @Override MicroserviceInstancesResponse getServiceCenterInstances(); @Override RegisteredMicroserviceResponse registerMicroservice(Microservice microservice); @Override MicroservicesResponse getMicroserviceList(); @Override RegisteredMicroserviceResponse queryServiceId(Microservice microservice); @Override Microservice getMicroserviceByServiceId(String serviceId); @Override RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance); @Override FindMicroserviceInstancesResponse findMicroserviceInstance(String consumerId, String appId, String serviceName,
String versionRule,
String revision); @Override MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId); @Override MicroserviceInstance getMicroserviceInstance(String serviceId, String instanceId); void deleteMicroserviceInstance(String serviceId, String instanceId); @Override boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId,
MicroserviceInstanceStatus status); void sendHeartBeats(HeartbeatsRequest heartbeatsRequest); @Override boolean sendHeartBeat(String serviceId, String instanceId); List<SchemaInfo> getServiceSchemasList(String serviceId); String getServiceSchemaContext(String serviceId, String schemaId); @Override boolean registerSchema(String serviceId, String schemaId, CreateSchemaRequest schema); @Override boolean updateServiceSchemaContext(String serviceId, SchemaInfo schemaInfo); @Override boolean batchUpdateServiceSchemaContext(String serviceId, ModifySchemasRequest modifySchemasRequest); }### Answer:
@Test public void TestGetServiceList() throws IOException { ServiceCenterRawClient serviceCenterRawClient = Mockito.mock(ServiceCenterRawClient.class); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("ok"); MicroservicesResponse microservicesResponse = new MicroservicesResponse(); List<Microservice> microserviceList = new ArrayList<Microservice>(); microserviceList.add(new Microservice("Test1")); microserviceList.add(new Microservice("Test2")); microserviceList.add(new Microservice("Test3")); microservicesResponse.setServices(microserviceList); ObjectMapper mapper = new ObjectMapper(); httpResponse.setContent(mapper.writeValueAsString(microservicesResponse)); Mockito.when(serviceCenterRawClient.getHttpRequest(Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(httpResponse); ServiceCenterClient serviceCenterClient = new ServiceCenterClient(serviceCenterRawClient); MicroservicesResponse actualMicroservicesResponse = serviceCenterClient.getMicroserviceList(); Assert.assertNotNull(actualMicroservicesResponse); Assert.assertEquals(3, actualMicroservicesResponse.getServices().size()); Assert.assertEquals("Test1", actualMicroservicesResponse.getServices().get(0).getServiceName()); }
|
### Question:
ServiceCenterClient implements ServiceCenterOperation { @Override public RegisteredMicroserviceResponse queryServiceId(Microservice microservice) { try { URIBuilder uriBuilder = new URIBuilder("/registry/existence"); uriBuilder.setParameter("type", "microservice"); uriBuilder.setParameter("appId", microservice.getAppId()); uriBuilder.setParameter("serviceName", microservice.getServiceName()); uriBuilder.setParameter("version", microservice.getVersion()); uriBuilder.setParameter("env", microservice.getEnvironment()); HttpResponse response = httpClient.getHttpRequest(uriBuilder.build().toString(), null, null); if (response.getStatusCode() == HttpStatus.SC_OK) { return HttpUtils.deserialize(response.getContent(), RegisteredMicroserviceResponse.class); } else { LOGGER.info("Query serviceId fails, statusCode = " + response.getStatusCode() + "; message = " + response .getMessage() + "; content = " + response.getContent()); return null; } } catch (IOException e) { throw new OperationException( "query serviceId fails", e); } catch (URISyntaxException e) { throw new OperationException( "build url failed.", e); } } ServiceCenterClient(ServiceCenterRawClient httpClient); ServiceCenterClient(AddressManager addressManager, SSLProperties sslProperties,
AKSKProperties akskProperties,
String tenantName,
Map<String, String> extraGlobalHeaders); @Override MicroserviceInstancesResponse getServiceCenterInstances(); @Override RegisteredMicroserviceResponse registerMicroservice(Microservice microservice); @Override MicroservicesResponse getMicroserviceList(); @Override RegisteredMicroserviceResponse queryServiceId(Microservice microservice); @Override Microservice getMicroserviceByServiceId(String serviceId); @Override RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance); @Override FindMicroserviceInstancesResponse findMicroserviceInstance(String consumerId, String appId, String serviceName,
String versionRule,
String revision); @Override MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId); @Override MicroserviceInstance getMicroserviceInstance(String serviceId, String instanceId); void deleteMicroserviceInstance(String serviceId, String instanceId); @Override boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId,
MicroserviceInstanceStatus status); void sendHeartBeats(HeartbeatsRequest heartbeatsRequest); @Override boolean sendHeartBeat(String serviceId, String instanceId); List<SchemaInfo> getServiceSchemasList(String serviceId); String getServiceSchemaContext(String serviceId, String schemaId); @Override boolean registerSchema(String serviceId, String schemaId, CreateSchemaRequest schema); @Override boolean updateServiceSchemaContext(String serviceId, SchemaInfo schemaInfo); @Override boolean batchUpdateServiceSchemaContext(String serviceId, ModifySchemasRequest modifySchemasRequest); }### Answer:
@Test public void TestQueryServiceId() throws IOException { ServiceCenterRawClient serviceCenterRawClient = Mockito.mock(ServiceCenterRawClient.class); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("ok"); httpResponse.setContent("{\"serviceId\": \"111111\"}"); Mockito.when(serviceCenterRawClient.getHttpRequest(Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(httpResponse); ServiceCenterClient serviceCenterClient = new ServiceCenterClient(serviceCenterRawClient); Microservice microservice = new Microservice("Test111"); RegisteredMicroserviceResponse actualServiceId = serviceCenterClient.queryServiceId(microservice); Assert.assertNotNull(actualServiceId); Assert.assertEquals("111111", actualServiceId.getServiceId()); }
|
### Question:
ServiceCenterClient implements ServiceCenterOperation { @Override public RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance) { try { CreateMicroserviceInstanceRequest request = new CreateMicroserviceInstanceRequest(); request.setInstance(instance); HttpResponse response = httpClient .postHttpRequest("/registry/microservices/" + instance.getServiceId() + "/instances", null, HttpUtils.serialize(request)); if (response.getStatusCode() == HttpStatus.SC_OK) { return HttpUtils.deserialize(response.getContent(), RegisteredMicroserviceInstanceResponse.class); } else { throw new OperationException( "register service instance fails, statusCode = " + response.getStatusCode() + "; message = " + response .getMessage() + "; content = " + response.getContent()); } } catch (IOException e) { throw new OperationException( "register service instance fails", e); } } ServiceCenterClient(ServiceCenterRawClient httpClient); ServiceCenterClient(AddressManager addressManager, SSLProperties sslProperties,
AKSKProperties akskProperties,
String tenantName,
Map<String, String> extraGlobalHeaders); @Override MicroserviceInstancesResponse getServiceCenterInstances(); @Override RegisteredMicroserviceResponse registerMicroservice(Microservice microservice); @Override MicroservicesResponse getMicroserviceList(); @Override RegisteredMicroserviceResponse queryServiceId(Microservice microservice); @Override Microservice getMicroserviceByServiceId(String serviceId); @Override RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance); @Override FindMicroserviceInstancesResponse findMicroserviceInstance(String consumerId, String appId, String serviceName,
String versionRule,
String revision); @Override MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId); @Override MicroserviceInstance getMicroserviceInstance(String serviceId, String instanceId); void deleteMicroserviceInstance(String serviceId, String instanceId); @Override boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId,
MicroserviceInstanceStatus status); void sendHeartBeats(HeartbeatsRequest heartbeatsRequest); @Override boolean sendHeartBeat(String serviceId, String instanceId); List<SchemaInfo> getServiceSchemasList(String serviceId); String getServiceSchemaContext(String serviceId, String schemaId); @Override boolean registerSchema(String serviceId, String schemaId, CreateSchemaRequest schema); @Override boolean updateServiceSchemaContext(String serviceId, SchemaInfo schemaInfo); @Override boolean batchUpdateServiceSchemaContext(String serviceId, ModifySchemasRequest modifySchemasRequest); }### Answer:
@Test public void TestRegisterServiceInstance() throws IOException { ServiceCenterRawClient serviceCenterRawClient = Mockito.mock(ServiceCenterRawClient.class); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("ok"); httpResponse.setContent("{\"instanceId\": \"111111\"}"); MicroserviceInstance instance = new MicroserviceInstance(); instance.setInstanceId("111111"); instance.setServiceId("222222"); ObjectMapper mapper = new ObjectMapper(); mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true); Mockito.when(serviceCenterRawClient.postHttpRequest("/registry/microservices/222222/instances", null, mapper.writeValueAsString(instance))) .thenReturn(httpResponse); ServiceCenterClient serviceCenterClient = new ServiceCenterClient(serviceCenterRawClient); RegisteredMicroserviceInstanceResponse actualResponse = serviceCenterClient.registerMicroserviceInstance(instance); Assert.assertNotNull(actualResponse); Assert.assertEquals("111111", actualResponse.getInstanceId()); }
|
### Question:
ServiceCenterClient implements ServiceCenterOperation { public void deleteMicroserviceInstance(String serviceId, String instanceId) { try { HttpResponse response = httpClient .deleteHttpRequest("/registry/microservices/" + serviceId + "/instances/" + instanceId, null, null); if (response.getStatusCode() == HttpStatus.SC_OK) { LOGGER.info("DELETE SERVICE INSTANCE OK"); } else { throw new OperationException( "delete service instance fails, statusCode = " + response.getStatusCode() + "; message = " + response .getMessage() + "; content = " + response.getContent()); } } catch (IOException e) { throw new OperationException( "delete service instance fails", e); } } ServiceCenterClient(ServiceCenterRawClient httpClient); ServiceCenterClient(AddressManager addressManager, SSLProperties sslProperties,
AKSKProperties akskProperties,
String tenantName,
Map<String, String> extraGlobalHeaders); @Override MicroserviceInstancesResponse getServiceCenterInstances(); @Override RegisteredMicroserviceResponse registerMicroservice(Microservice microservice); @Override MicroservicesResponse getMicroserviceList(); @Override RegisteredMicroserviceResponse queryServiceId(Microservice microservice); @Override Microservice getMicroserviceByServiceId(String serviceId); @Override RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance); @Override FindMicroserviceInstancesResponse findMicroserviceInstance(String consumerId, String appId, String serviceName,
String versionRule,
String revision); @Override MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId); @Override MicroserviceInstance getMicroserviceInstance(String serviceId, String instanceId); void deleteMicroserviceInstance(String serviceId, String instanceId); @Override boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId,
MicroserviceInstanceStatus status); void sendHeartBeats(HeartbeatsRequest heartbeatsRequest); @Override boolean sendHeartBeat(String serviceId, String instanceId); List<SchemaInfo> getServiceSchemasList(String serviceId); String getServiceSchemaContext(String serviceId, String schemaId); @Override boolean registerSchema(String serviceId, String schemaId, CreateSchemaRequest schema); @Override boolean updateServiceSchemaContext(String serviceId, SchemaInfo schemaInfo); @Override boolean batchUpdateServiceSchemaContext(String serviceId, ModifySchemasRequest modifySchemasRequest); }### Answer:
@Test public void TestDeleteServiceInstance() throws IOException { ServiceCenterRawClient serviceCenterRawClient = Mockito.mock(ServiceCenterRawClient.class); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("ok"); Mockito.when(serviceCenterRawClient.deleteHttpRequest(Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(httpResponse); ServiceCenterClient serviceCenterClient = new ServiceCenterClient(serviceCenterRawClient); serviceCenterClient.deleteMicroserviceInstance("111", "222"); }
|
### Question:
ServiceCenterClient implements ServiceCenterOperation { @Override public MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId) { try { HttpResponse response = httpClient .getHttpRequest("/registry/microservices/" + serviceId + "/instances", null, null); if (response.getStatusCode() == HttpStatus.SC_OK) { return HttpUtils.deserialize(response.getContent(), MicroserviceInstancesResponse.class); } else { throw new OperationException( "get service instances list fails, statusCode = " + response.getStatusCode() + "; message = " + response .getMessage() + "; content = " + response.getContent()); } } catch (IOException e) { throw new OperationException( "get service instances list fails", e); } } ServiceCenterClient(ServiceCenterRawClient httpClient); ServiceCenterClient(AddressManager addressManager, SSLProperties sslProperties,
AKSKProperties akskProperties,
String tenantName,
Map<String, String> extraGlobalHeaders); @Override MicroserviceInstancesResponse getServiceCenterInstances(); @Override RegisteredMicroserviceResponse registerMicroservice(Microservice microservice); @Override MicroservicesResponse getMicroserviceList(); @Override RegisteredMicroserviceResponse queryServiceId(Microservice microservice); @Override Microservice getMicroserviceByServiceId(String serviceId); @Override RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance); @Override FindMicroserviceInstancesResponse findMicroserviceInstance(String consumerId, String appId, String serviceName,
String versionRule,
String revision); @Override MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId); @Override MicroserviceInstance getMicroserviceInstance(String serviceId, String instanceId); void deleteMicroserviceInstance(String serviceId, String instanceId); @Override boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId,
MicroserviceInstanceStatus status); void sendHeartBeats(HeartbeatsRequest heartbeatsRequest); @Override boolean sendHeartBeat(String serviceId, String instanceId); List<SchemaInfo> getServiceSchemasList(String serviceId); String getServiceSchemaContext(String serviceId, String schemaId); @Override boolean registerSchema(String serviceId, String schemaId, CreateSchemaRequest schema); @Override boolean updateServiceSchemaContext(String serviceId, SchemaInfo schemaInfo); @Override boolean batchUpdateServiceSchemaContext(String serviceId, ModifySchemasRequest modifySchemasRequest); }### Answer:
@Test public void TestGetServiceInstanceList() throws IOException { ServiceCenterRawClient serviceCenterRawClient = Mockito.mock(ServiceCenterRawClient.class); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("ok"); String responseString = "{\n" + " \"instances\": [\n" + " {\n" + " \"instanceId\": \"111111\",\n" + " \"serviceId\": \"222222\",\n" + " \"version\": \"1.0\",\n" + " \"hostName\": \"Test\",\n" + " \"endpoints\": [\n" + " \"string\"\n" + " ],\n" + " \"status\": \"UP\",\n" + " \"timestamp\": \"333333\",\n" + " \"modTimestamp\": \"4444444\"\n" + " }\n" + " ]\n" + "}"; httpResponse.setContent(responseString); Mockito.when(serviceCenterRawClient.getHttpRequest("/registry/microservices/222222/instances", null, null)) .thenReturn(httpResponse); ServiceCenterClient serviceCenterClient = new ServiceCenterClient(serviceCenterRawClient); MicroserviceInstancesResponse serviceCenterInstances = serviceCenterClient .getMicroserviceInstanceList("222222"); Assert.assertNotNull(serviceCenterInstances); Assert.assertEquals(1, serviceCenterInstances.getInstances().size()); Assert.assertEquals("111111", serviceCenterInstances.getInstances().get(0).getInstanceId()); Assert.assertEquals("222222", serviceCenterInstances.getInstances().get(0).getServiceId()); }
|
### Question:
ServiceCenterClient implements ServiceCenterOperation { public void sendHeartBeats(HeartbeatsRequest heartbeatsRequest) { try { HttpResponse response = httpClient .putHttpRequest("/registry/heartbeats", null, HttpUtils.serialize(heartbeatsRequest)); if (response.getStatusCode() == HttpStatus.SC_OK) { LOGGER.info("HEARTBEATS SUCCESS"); } else { throw new OperationException( "heartbeats fails, statusCode = " + response.getStatusCode() + "; message = " + response.getMessage() + "; content = " + response.getContent()); } } catch (IOException e) { throw new OperationException( "heartbeats fails ", e); } } ServiceCenterClient(ServiceCenterRawClient httpClient); ServiceCenterClient(AddressManager addressManager, SSLProperties sslProperties,
AKSKProperties akskProperties,
String tenantName,
Map<String, String> extraGlobalHeaders); @Override MicroserviceInstancesResponse getServiceCenterInstances(); @Override RegisteredMicroserviceResponse registerMicroservice(Microservice microservice); @Override MicroservicesResponse getMicroserviceList(); @Override RegisteredMicroserviceResponse queryServiceId(Microservice microservice); @Override Microservice getMicroserviceByServiceId(String serviceId); @Override RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance); @Override FindMicroserviceInstancesResponse findMicroserviceInstance(String consumerId, String appId, String serviceName,
String versionRule,
String revision); @Override MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId); @Override MicroserviceInstance getMicroserviceInstance(String serviceId, String instanceId); void deleteMicroserviceInstance(String serviceId, String instanceId); @Override boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId,
MicroserviceInstanceStatus status); void sendHeartBeats(HeartbeatsRequest heartbeatsRequest); @Override boolean sendHeartBeat(String serviceId, String instanceId); List<SchemaInfo> getServiceSchemasList(String serviceId); String getServiceSchemaContext(String serviceId, String schemaId); @Override boolean registerSchema(String serviceId, String schemaId, CreateSchemaRequest schema); @Override boolean updateServiceSchemaContext(String serviceId, SchemaInfo schemaInfo); @Override boolean batchUpdateServiceSchemaContext(String serviceId, ModifySchemasRequest modifySchemasRequest); }### Answer:
@Test public void TestSendHeartBeats() throws IOException { ServiceCenterRawClient serviceCenterRawClient = Mockito.mock(ServiceCenterRawClient.class); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("ok"); HeartbeatsRequest heartbeatsRequest = new HeartbeatsRequest("001", "1001"); heartbeatsRequest.addInstances(new InstancesRequest("002", "1002")); ObjectMapper mapper = new ObjectMapper(); Mockito .when(serviceCenterRawClient.putHttpRequest("/registry/microservices/111/instances/222/heartbeat", null, null)) .thenReturn(httpResponse); Mockito.when(serviceCenterRawClient .putHttpRequest("/registry/heartbeats", null, mapper.writeValueAsString(heartbeatsRequest))) .thenReturn(httpResponse); ServiceCenterClient serviceCenterClient = new ServiceCenterClient(serviceCenterRawClient); serviceCenterClient.sendHeartBeats(heartbeatsRequest); }
|
### Question:
ServiceCenterClient implements ServiceCenterOperation { @Override public boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId, MicroserviceInstanceStatus status) { try { HttpResponse response = httpClient.putHttpRequest( "/registry/microservices/" + serviceId + "/instances/" + instanceId + "/status?value=" + status, null, null); if (response.getStatusCode() == HttpStatus.SC_OK) { LOGGER.info("UPDATE STATUS OK"); return true; } else { throw new OperationException( "update service instance status fails, statusCode = " + response.getStatusCode() + "; message = " + response .getMessage() + "; content = " + response.getContent()); } } catch (IOException e) { throw new OperationException( "update service instance status fails", e); } } ServiceCenterClient(ServiceCenterRawClient httpClient); ServiceCenterClient(AddressManager addressManager, SSLProperties sslProperties,
AKSKProperties akskProperties,
String tenantName,
Map<String, String> extraGlobalHeaders); @Override MicroserviceInstancesResponse getServiceCenterInstances(); @Override RegisteredMicroserviceResponse registerMicroservice(Microservice microservice); @Override MicroservicesResponse getMicroserviceList(); @Override RegisteredMicroserviceResponse queryServiceId(Microservice microservice); @Override Microservice getMicroserviceByServiceId(String serviceId); @Override RegisteredMicroserviceInstanceResponse registerMicroserviceInstance(MicroserviceInstance instance); @Override FindMicroserviceInstancesResponse findMicroserviceInstance(String consumerId, String appId, String serviceName,
String versionRule,
String revision); @Override MicroserviceInstancesResponse getMicroserviceInstanceList(String serviceId); @Override MicroserviceInstance getMicroserviceInstance(String serviceId, String instanceId); void deleteMicroserviceInstance(String serviceId, String instanceId); @Override boolean updateMicroserviceInstanceStatus(String serviceId, String instanceId,
MicroserviceInstanceStatus status); void sendHeartBeats(HeartbeatsRequest heartbeatsRequest); @Override boolean sendHeartBeat(String serviceId, String instanceId); List<SchemaInfo> getServiceSchemasList(String serviceId); String getServiceSchemaContext(String serviceId, String schemaId); @Override boolean registerSchema(String serviceId, String schemaId, CreateSchemaRequest schema); @Override boolean updateServiceSchemaContext(String serviceId, SchemaInfo schemaInfo); @Override boolean batchUpdateServiceSchemaContext(String serviceId, ModifySchemasRequest modifySchemasRequest); }### Answer:
@Test public void TestUpdateServicesInstanceStatus() throws IOException { ServiceCenterRawClient serviceCenterRawClient = Mockito.mock(ServiceCenterRawClient.class); HttpResponse httpResponse = new HttpResponse(); httpResponse.setStatusCode(200); httpResponse.setMessage("ok"); Mockito.when(serviceCenterRawClient.putHttpRequest(Mockito.any(), Mockito.any(), Mockito.any())) .thenReturn(httpResponse); ServiceCenterClient serviceCenterClient = new ServiceCenterClient(serviceCenterRawClient); Boolean result = serviceCenterClient .updateMicroserviceInstanceStatus("111", "222", MicroserviceInstanceStatus.UP); Assert.assertNotNull(result); Assert.assertEquals(true, result); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.