src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
RestClientInvocation { protected void handleResponse(HttpClientResponse httpClientResponse) { this.clientResponse = httpClientResponse; if (HttpStatus.isSuccess(clientResponse.statusCode()) && restOperationMeta.isDownloadFile()) { ReadStreamPart part = new ReadStreamPart(httpClientWithContext.context(), httpClientResponse); invocation.getHandlerContext().put(RestConst.READ_STREAM_PART, part); processResponseBody(null); return; } httpClientResponse.exceptionHandler(e -> { invocation.getTraceIdLogger().error(LOGGER, "Failed to receive response, local:{}, remote:{}, message={}.", getLocalAddress(), httpClientResponse.netSocket().remoteAddress(), ExceptionUtils.getExceptionMessageWithoutTrace(e)); fail((ConnectionBase) clientRequest.connection(), e); }); clientResponse.bodyHandler(this::processResponseBody); } RestClientInvocation(HttpClientWithContext httpClientWithContext, List<HttpClientFilter> httpClientFilters); void invoke(Invocation invocation, AsyncResponse asyncResp); } | @SuppressWarnings("unchecked") @Test public void handleResponse() { HttpClientResponse httpClientResponse = mock(HttpClientResponse.class); doAnswer(a -> { bodyHandler = (Handler<Buffer>) a.getArguments()[0]; return httpClientResponse; }).when(httpClientResponse).bodyHandler(any()); Buffer buf = Buffer.buffer(); new MockUp<RestClientInvocation>(restClientInvocation) { @Mock void processResponseBody(Buffer responseBuf) { asyncResp.success(buf); } }; restClientInvocation.handleResponse(httpClientResponse); bodyHandler.handle(buf); Assert.assertSame(buf, response.getResult()); }
@SuppressWarnings("unchecked") @Test public void handleResponse_responseException() { HttpClientResponse httpClientResponse = mock(HttpClientResponse.class); NetSocket netSocket = mock(NetSocket.class); when(httpClientResponse.netSocket()).thenReturn(netSocket); when(netSocket.remoteAddress()).thenReturn(mock(SocketAddress.class)); doAnswer(a -> { exceptionHandler = (Handler<Throwable>) a.getArguments()[0]; return httpClientResponse; }).when(httpClientResponse).exceptionHandler(any()); restClientInvocation.handleResponse(httpClientResponse); RuntimeException error = new RuntimeExceptionWithoutStackTrace(); exceptionHandler.handle(error); Assert.assertThat(((InvocationException) response.getResult()).getCause(), Matchers.sameInstance(error)); } |
RestClientInvocation { protected void processResponseBody(Buffer responseBuf) { DefaultHttpSocketMetric httpSocketMetric = (DefaultHttpSocketMetric) ((ConnectionBase) clientRequest.connection()) .metric(); invocation.getInvocationStageTrace().finishGetConnection(httpSocketMetric.getRequestBeginTime()); invocation.getInvocationStageTrace().finishWriteToBuffer(httpSocketMetric.getRequestEndTime()); invocation.getInvocationStageTrace().finishReceiveResponse(); invocation.getResponseExecutor().execute(() -> { try { invocation.getInvocationStageTrace().startClientFiltersResponse(); HttpServletResponseEx responseEx = new VertxClientResponseToHttpServletResponse(clientResponse, responseBuf); for (HttpClientFilter filter : httpClientFilters) { if (filter.enabled()) { Response response = filter.afterReceiveResponse(invocation, responseEx); if (response != null) { complete(response); return; } } } } catch (Throwable e) { fail(null, e); } }); } RestClientInvocation(HttpClientWithContext httpClientWithContext, List<HttpClientFilter> httpClientFilters); void invoke(Invocation invocation, AsyncResponse asyncResp); } | @Test public void processResponseBody() { Response resp = Response.ok(null); HttpClientResponse httpClientResponse = mock(HttpClientResponse.class); Deencapsulation.setField(restClientInvocation, "clientResponse", httpClientResponse); { HttpClientFilter filter = mock(HttpClientFilter.class); when(filter.afterReceiveResponse(any(), any())).thenReturn(null); when(filter.enabled()).thenReturn(true); httpClientFilters.add(filter); } { HttpClientFilter filter = mock(HttpClientFilter.class); when(filter.afterReceiveResponse(any(), any())).thenReturn(resp); when(filter.enabled()).thenReturn(true); httpClientFilters.add(filter); } when(invocation.getResponseExecutor()).thenReturn(new ReactiveExecutor()); new Expectations() { { connectionBase.metric(); result = Mockito.mock(DefaultHttpSocketMetric.class); } }; DefaultHttpSocketMetric httpSocketMetric = new DefaultHttpSocketMetric(Mockito.mock(DefaultEndpointMetric.class)); httpSocketMetric.requestBegin(); httpSocketMetric.requestEnd(); new Expectations() { { connectionBase.metric(); result = httpSocketMetric; } }; when(request.connection()).thenReturn(connectionBase); restClientInvocation.processResponseBody(null); Assert.assertSame(resp, response); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartClientFiltersResponse()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishClientFiltersResponse()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishReceiveResponse()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishGetConnection()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishWriteToBuffer()); }
@SuppressWarnings("unchecked") @Test public void processResponseBody_throw() { HttpClientResponse httpClientResponse = mock(HttpClientResponse.class); Deencapsulation.setField(restClientInvocation, "clientResponse", httpClientResponse); { HttpClientFilter filter = mock(HttpClientFilter.class); when(filter.afterReceiveResponse(any(), any())).thenThrow(Error.class); when(filter.enabled()).thenReturn(true); httpClientFilters.add(filter); } when(invocation.getResponseExecutor()).thenReturn(new ReactiveExecutor()); new Expectations() { { connectionBase.metric(); result = Mockito.mock(DefaultHttpSocketMetric.class); } }; DefaultHttpSocketMetric httpSocketMetric = new DefaultHttpSocketMetric(Mockito.mock(DefaultEndpointMetric.class)); httpSocketMetric.requestBegin(); httpSocketMetric.requestEnd(); new Expectations() { { connectionBase.metric(); result = httpSocketMetric; } }; when(request.connection()).thenReturn(connectionBase); restClientInvocation.processResponseBody(null); Assert.assertThat(((InvocationException) response.getResult()).getCause(), Matchers.instanceOf(Error.class)); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getStartClientFiltersResponse()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishClientFiltersResponse()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishReceiveResponse()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishGetConnection()); Assert.assertEquals(nanoTime, invocation.getInvocationStageTrace().getFinishWriteToBuffer()); } |
RestClientInvocation { protected String createRequestPath(RestOperationMeta swaggerRestOperation) throws Exception { URIEndpointObject address = (URIEndpointObject) invocation.getEndpoint().getAddress(); String urlPrefix = address.getFirst(DefinitionConst.URL_PREFIX); String path = (String) invocation.getHandlerContext().get(RestConst.REST_CLIENT_REQUEST_PATH); if (path == null) { path = swaggerRestOperation.getPathBuilder().createRequestPath(invocation.getSwaggerArguments()); } if (StringUtils.isEmpty(urlPrefix) || path.startsWith(urlPrefix)) { return path; } return urlPrefix + path; } RestClientInvocation(HttpClientWithContext httpClientWithContext, List<HttpClientFilter> httpClientFilters); void invoke(Invocation invocation, AsyncResponse asyncResp); } | @Test public void createRequestPath_NoUrlPrefixNoPath() throws Exception { when(address.getFirst(DefinitionConst.URL_PREFIX)).thenReturn(null); when(urlPathBuilder.createRequestPath(any())).thenReturn("/path"); String path = restClientInvocation.createRequestPath(swaggerRestOperation); Assert.assertEquals("/path", path); }
@Test public void createRequestPath_noUrlPrefixHavePath() throws Exception { handlerContext.put(RestConst.REST_CLIENT_REQUEST_PATH, "/client/path"); when(address.getFirst(DefinitionConst.URL_PREFIX)).thenReturn(null); String path = restClientInvocation.createRequestPath(swaggerRestOperation); Assert.assertEquals("/client/path", path); }
@Test public void createRequestPath_haveUrlPrefixNoPath() throws Exception { when(address.getFirst(DefinitionConst.URL_PREFIX)).thenReturn("/prefix"); when(urlPathBuilder.createRequestPath(any())).thenReturn("/path"); String path = restClientInvocation.createRequestPath(swaggerRestOperation); Assert.assertEquals("/prefix/path", path); }
@Test public void createRequestPath_haveUrlPrefixHavePath() throws Exception { when(address.getFirst(DefinitionConst.URL_PREFIX)).thenReturn("/prefix"); handlerContext.put(RestConst.REST_CLIENT_REQUEST_PATH, "/client/path"); String path = restClientInvocation.createRequestPath(swaggerRestOperation); Assert.assertEquals("/prefix/client/path", path); }
@Test public void createRequestPath_haveUrlPrefixHavePathAndStartWith() throws Exception { when(address.getFirst(DefinitionConst.URL_PREFIX)).thenReturn("/prefix"); handlerContext.put(RestConst.REST_CLIENT_REQUEST_PATH, "/prefix/client/path"); String path = restClientInvocation.createRequestPath(swaggerRestOperation); Assert.assertEquals("/prefix/client/path", path); } |
PublishUtils { public static PerfInfo createPerfInfo(MeasurementNode stageNode) { PerfInfo perfInfo = new PerfInfo(); perfInfo.setTps(stageNode.findChild(Statistic.count.name()).summary()); perfInfo.setMsTotalTime(stageNode.findChild(Statistic.totalTime.name()).summary() * 1000); MeasurementNode maxNode = stageNode.findChild(Statistic.max.name()); if (maxNode != null) { perfInfo.setMsMaxLatency(maxNode.summary() * 1000); } return perfInfo; } private PublishUtils(); static PerfInfo createPerfInfo(MeasurementNode stageNode); static OperationPerf createOperationPerf(String operation, MeasurementNode statusNode); static void addOperationPerfGroups(OperationPerfGroups operationPerfGroups, String transport, String operation,
MeasurementNode statusNode); } | @Test public void createPerfInfo() { MeasurementNode stageNode = Utils.createStageNode(MeterInvocationConst.STAGE_TOTAL, 10, 10, 100); PerfInfo perf = PublishUtils.createPerfInfo(stageNode); Assert.assertEquals(10, perf.getTps(), 0); Assert.assertEquals(1000, perf.calcMsLatency(), 0); Assert.assertEquals(100000, perf.getMsMaxLatency(), 0); } |
DefaultHttpClientFilter implements HttpClientFilter { @Override public int getOrder() { return Integer.MAX_VALUE; } @Override int getOrder(); @Override boolean enabled(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); } | @Test public void testOrder() { Assert.assertEquals(Integer.MAX_VALUE, filter.getOrder()); } |
DefaultHttpClientFilter implements HttpClientFilter { protected ProduceProcessor findProduceProcessor(RestOperationMeta restOperation, HttpServletResponseEx responseEx) { String contentType = responseEx.getHeader(HttpHeaders.CONTENT_TYPE); if (contentType == null) { return null; } String contentTypeForFind = contentType; int idx = contentType.indexOf(';'); if (idx != -1) { contentTypeForFind = contentType.substring(0, idx); } return restOperation.findProduceProcessor(contentTypeForFind); } @Override int getOrder(); @Override boolean enabled(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); } | @Test public void testFindProduceProcessorNullContentType(@Mocked RestOperationMeta restOperation, @Mocked HttpServletResponseEx responseEx) { new Expectations() { { responseEx.getHeader(HttpHeaders.CONTENT_TYPE); result = null; } }; Assert.assertNull(filter.findProduceProcessor(restOperation, responseEx)); }
@Test public void testFindProduceProcessorJson(@Mocked RestOperationMeta restOperation, @Mocked HttpServletResponseEx responseEx, @Mocked ProduceProcessor produceProcessor) { new Expectations() { { responseEx.getHeader(HttpHeaders.CONTENT_TYPE); result = "json"; restOperation.findProduceProcessor("json"); result = produceProcessor; } }; Assert.assertSame(produceProcessor, filter.findProduceProcessor(restOperation, responseEx)); }
@Test public void testFindProduceProcessorJsonWithCharset(@Mocked RestOperationMeta restOperation, @Mocked HttpServletResponseEx responseEx, @Mocked ProduceProcessor produceProcessor) { new Expectations() { { responseEx.getHeader(HttpHeaders.CONTENT_TYPE); result = "json; UTF-8"; restOperation.findProduceProcessor("json"); result = produceProcessor; } }; Assert.assertSame(produceProcessor, filter.findProduceProcessor(restOperation, responseEx)); } |
DefaultHttpClientFilter implements HttpClientFilter { protected Response extractResponse(Invocation invocation, HttpServletResponseEx responseEx) { Object result = invocation.getHandlerContext().get(RestConst.READ_STREAM_PART); if (result != null) { return Response.create(responseEx.getStatusType(), result); } OperationMeta operationMeta = invocation.getOperationMeta(); JavaType responseType = invocation.findResponseType(responseEx.getStatus()); RestOperationMeta swaggerRestOperation = operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); ProduceProcessor produceProcessor = findProduceProcessor(swaggerRestOperation, responseEx); if (produceProcessor == null) { String msg = String.format("method %s, path %s, statusCode %d, reasonPhrase %s, response content-type %s is not supported", swaggerRestOperation.getHttpMethod(), swaggerRestOperation.getAbsolutePath(), responseEx.getStatus(), responseEx.getStatusType().getReasonPhrase(), responseEx.getHeader(HttpHeaders.CONTENT_TYPE)); LOGGER.warn(msg); produceProcessor = ProduceProcessorManager.INSTANCE.findDefaultProcessor(); } try { result = produceProcessor.decodeResponse(responseEx.getBodyBuffer(), responseType); return Response.create(responseEx.getStatusType(), result); } catch (Exception e) { LOGGER.error("failed to decode response body, exception is [{}]", e.getMessage()); String msg = String.format("method %s, path %s, statusCode %d, reasonPhrase %s, response content-type %s is not supported", swaggerRestOperation.getHttpMethod(), swaggerRestOperation.getAbsolutePath(), responseEx.getStatus(), responseEx.getStatusType().getReasonPhrase(), responseEx.getHeader(HttpHeaders.CONTENT_TYPE)); if (HttpStatus.isSuccess(responseEx.getStatus())) { return Response.createConsumerFail( new InvocationException(400, responseEx.getStatusType().getReasonPhrase(), new CommonExceptionData(msg), e)); } return Response.createConsumerFail( new InvocationException(responseEx.getStatus(), responseEx.getStatusType().getReasonPhrase(), new CommonExceptionData(msg), e)); } } @Override int getOrder(); @Override boolean enabled(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); } | @Test public void extractResult_readStreamPart(@Mocked Invocation invocation, @Mocked ReadStreamPart part, @Mocked HttpServletResponseEx responseEx) { Map<String, Object> handlerContext = new HashMap<>(); handlerContext.put(RestConst.READ_STREAM_PART, part); new Expectations() { { invocation.getHandlerContext(); result = handlerContext; responseEx.getStatusType(); result = Status.OK; } }; Response response = filter.extractResponse(invocation, responseEx); Assert.assertSame(part, response.getResult()); Assert.assertEquals(Status.OK, response.getStatus()); }
@Test public void extractResult_decodeError(@Mocked Invocation invocation, @Mocked ReadStreamPart part, @Mocked OperationMeta operationMeta, @Mocked RestOperationMeta swaggerRestOperation, @Mocked HttpServletResponseEx responseEx) { Map<String, Object> handlerContext = new HashMap<>(); new Expectations() { { invocation.getHandlerContext(); result = handlerContext; invocation.getOperationMeta(); result = operationMeta; invocation.findResponseType(400); result = SimpleType.constructUnsafe(Date.class); operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = swaggerRestOperation; responseEx.getStatus(); result = 400; responseEx.getBodyBuffer(); result = new BufferImpl().appendString("abc"); } }; new MockUp<DefaultHttpClientFilter>() { @Mock ProduceProcessor findProduceProcessor(RestOperationMeta restOperation, HttpServletResponseEx responseEx) { return new ProduceJsonProcessor(); } }; Response response = filter.extractResponse(invocation, responseEx); Assert.assertEquals(400, response.getStatusCode()); Assert.assertEquals(InvocationException.class, response.<InvocationException>getResult().getClass()); InvocationException invocationException = response.getResult(); Assert.assertEquals( "InvocationException: code=400;msg=CommonExceptionData [message=method null, path null, statusCode 400, reasonPhrase null, response content-type null is not supported]", invocationException.getMessage()); Assert.assertEquals("Unrecognized token 'abc': was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false')\n" + " at [Source: (org.apache.servicecomb.foundation.vertx.stream.BufferInputStream); line: 1, column: 7]", invocationException.getCause().getMessage()); Assert.assertEquals(CommonExceptionData.class, invocationException.getErrorData().getClass()); CommonExceptionData commonExceptionData = (CommonExceptionData) invocationException.getErrorData(); Assert.assertEquals( "method null, path null, statusCode 400, reasonPhrase null, response content-type null is not supported", commonExceptionData.getMessage()); }
@Test public void extractResult_decodeError200(@Mocked Invocation invocation, @Mocked ReadStreamPart part, @Mocked OperationMeta operationMeta, @Mocked RestOperationMeta swaggerRestOperation, @Mocked HttpServletResponseEx responseEx) { Map<String, Object> handlerContext = new HashMap<>(); new Expectations() { { invocation.getHandlerContext(); result = handlerContext; invocation.getOperationMeta(); result = operationMeta; invocation.findResponseType(200); result = SimpleType.constructUnsafe(Date.class); operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = swaggerRestOperation; responseEx.getStatus(); result = 200; responseEx.getBodyBuffer(); result = new BufferImpl().appendString("abc"); } }; new MockUp<DefaultHttpClientFilter>() { @Mock ProduceProcessor findProduceProcessor(RestOperationMeta restOperation, HttpServletResponseEx responseEx) { return new ProduceJsonProcessor(); } }; Response response = filter.extractResponse(invocation, responseEx); Assert.assertEquals(400, response.getStatusCode()); Assert.assertEquals(InvocationException.class, response.<InvocationException>getResult().getClass()); InvocationException invocationException = response.getResult(); Assert.assertEquals( "InvocationException: code=400;msg=CommonExceptionData [message=method null, path null, statusCode 200, reasonPhrase null, response content-type null is not supported]", invocationException.getMessage()); Assert.assertEquals("Unrecognized token 'abc': was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false')\n" + " at [Source: (org.apache.servicecomb.foundation.vertx.stream.BufferInputStream); line: 1, column: 7]", invocationException.getCause().getMessage()); Assert.assertEquals(CommonExceptionData.class, invocationException.getErrorData().getClass()); CommonExceptionData commonExceptionData = (CommonExceptionData) invocationException.getErrorData(); Assert.assertEquals( "method null, path null, statusCode 200, reasonPhrase null, response content-type null is not supported", commonExceptionData.getMessage()); } |
DefaultHttpClientFilter implements HttpClientFilter { @Override public Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx) { Response response = extractResponse(invocation, responseEx); for (String headerName : responseEx.getHeaderNames()) { if (headerName.equals(":status")) { continue; } Collection<String> headerValues = responseEx.getHeaders(headerName); for (String headerValue : headerValues) { response.getHeaders().addHeader(headerName, headerValue); } } return response; } @Override int getOrder(); @Override boolean enabled(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); } | @Test public void testAfterReceiveResponseNullProduceProcessor(@Mocked Invocation invocation, @Mocked HttpServletResponseEx responseEx, @Mocked OperationMeta operationMeta, @Mocked RestOperationMeta swaggerRestOperation) throws Exception { CommonExceptionData data = new CommonExceptionData("abcd"); new Expectations() { { invocation.getOperationMeta(); result = operationMeta; operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION); result = swaggerRestOperation; invocation.findResponseType(403); result = SimpleType.constructUnsafe(CommonExceptionData.class); responseEx.getStatus(); result = 403; responseEx.getStatusType(); result = Status.FORBIDDEN; responseEx.getBodyBuffer(); result = Buffer.buffer(JsonUtils.writeValueAsString(data).getBytes()); } }; Response response = filter.afterReceiveResponse(invocation, responseEx); Assert.assertEquals(403, response.getStatusCode()); Assert.assertEquals("Forbidden", response.getReasonPhrase()); Assert.assertEquals(InvocationException.class, response.<InvocationException>getResult().getClass()); InvocationException invocationException = response.getResult(); Assert.assertEquals( 403, invocationException.getStatusCode()); Assert.assertEquals( "CommonExceptionData [message=abcd]", invocationException.getErrorData().toString()); } |
PublishUtils { public static OperationPerf createOperationPerf(String operation, MeasurementNode statusNode) { OperationPerf operationPerf = new OperationPerf(); operationPerf.setOperation(operation); MeasurementNode stageNode = statusNode.findChild(MeterInvocationConst.TAG_STAGE); stageNode.getChildren().values().forEach(mNode -> { PerfInfo perfInfo = createPerfInfo(mNode); operationPerf.getStages().put(mNode.getName(), perfInfo); }); MeasurementNode latencyNode = statusNode.findChild(MeterInvocationConst.TAG_LATENCY_DISTRIBUTION); if (latencyNode != null && latencyNode.getMeasurements() != null) { operationPerf.setLatencyDistribution(latencyNode.getMeasurements().stream() .map(m -> (int) m.value()) .toArray(Integer[]::new)); } return operationPerf; } private PublishUtils(); static PerfInfo createPerfInfo(MeasurementNode stageNode); static OperationPerf createOperationPerf(String operation, MeasurementNode statusNode); static void addOperationPerfGroups(OperationPerfGroups operationPerfGroups, String transport, String operation,
MeasurementNode statusNode); } | @Test public void createOperationPerf() { OperationPerf opPerf = Utils.createOperationPerf(op); PerfInfo perfInfo = opPerf.findStage(MeterInvocationConst.STAGE_TOTAL); Integer[] latencyDistribution = opPerf.getLatencyDistribution(); Assert.assertEquals(10, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); Assert.assertEquals(2, latencyDistribution.length); Assert.assertEquals(1, latencyDistribution[0].intValue()); Assert.assertEquals(2, latencyDistribution[1].intValue()); } |
TransportClientConfig { public static int getThreadCount() { return TransportConfigUtils.readVerticleCount( "servicecomb.rest.client.verticle-count", "servicecomb.rest.client.thread-count"); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getThreadCount() { ArchaiusUtils.setProperty("servicecomb.rest.client.verticle-count", 1); Assert.assertEquals(1, TransportClientConfig.getThreadCount()); } |
TransportClientConfig { public static int getConnectionMaxPoolSize() { return DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.client.connection.maxPoolSize", HttpClientOptions.DEFAULT_MAX_POOL_SIZE) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getConnectionMaxPoolSize() { Assert.assertEquals(5, TransportClientConfig.getConnectionMaxPoolSize()); } |
TransportClientConfig { public static int getConnectionIdleTimeoutInSeconds() { return DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.client.connection.idleTimeoutInSeconds", 60) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getConnectionIdleTimeoutInSeconds() { Assert.assertEquals(60, TransportClientConfig.getConnectionIdleTimeoutInSeconds()); } |
TransportClientConfig { public static int getHttp2MultiplexingLimit() { return DynamicPropertyFactory.getInstance().getIntProperty("servicecomb.rest.client.http2.multiplexingLimit", HttpClientOptions.DEFAULT_HTTP2_MULTIPLEXING_LIMIT) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getHttp2MultiplexingLimit() { Assert.assertEquals(-1, TransportClientConfig.getHttp2MultiplexingLimit()); } |
TransportClientConfig { public static int getHttp2ConnectionMaxPoolSize() { return DynamicPropertyFactory.getInstance().getIntProperty("servicecomb.rest.client.http2.maxPoolSize", HttpClientOptions.DEFAULT_HTTP2_MAX_POOL_SIZE) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getHttp2ConnectionMaxPoolSize() { Assert.assertEquals(1, TransportClientConfig.getHttp2ConnectionMaxPoolSize()); } |
TransportClientConfig { public static int getHttp2ConnectionIdleTimeoutInSeconds() { return DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.client.http2.idleTimeoutInSeconds", TCPSSLOptions.DEFAULT_IDLE_TIMEOUT) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getHttp2ConnectionIdleTimeoutInSeconds() { Assert.assertEquals(0, TransportClientConfig.getHttp2ConnectionIdleTimeoutInSeconds()); } |
TransportClientConfig { public static boolean getUseAlpn() { return DynamicPropertyFactory.getInstance() .getBooleanProperty("servicecomb.rest.client.http2.useAlpnEnabled", true) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getUseAlpnEnabled() { Assert.assertTrue(TransportClientConfig.getUseAlpn()); } |
TransportClientConfig { public static boolean getConnectionKeepAlive() { return DynamicPropertyFactory.getInstance() .getBooleanProperty("servicecomb.rest.client.connection.keepAlive", HttpClientOptions.DEFAULT_KEEP_ALIVE) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getConnectionKeepAlive() { Assert.assertTrue(TransportClientConfig.getConnectionKeepAlive()); } |
TransportClientConfig { public static boolean getConnectionCompression() { return DynamicPropertyFactory.getInstance() .getBooleanProperty("servicecomb.rest.client.connection.compression", HttpClientOptions.DEFAULT_TRY_USE_COMPRESSION) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getConnectionCompression() { Assert.assertFalse(TransportClientConfig.getConnectionCompression()); } |
TransportClientConfig { public static int getMaxHeaderSize() { return DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.client.maxHeaderSize", HttpClientOptions.DEFAULT_MAX_HEADER_SIZE) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getMaxHeaderSize() { Assert.assertEquals(8192, TransportClientConfig.getMaxHeaderSize()); ArchaiusUtils.setProperty("servicecomb.rest.client.maxHeaderSize", 1024); Assert.assertEquals(1024, TransportClientConfig.getMaxHeaderSize()); } |
PublishUtils { public static void addOperationPerfGroups(OperationPerfGroups operationPerfGroups, String transport, String operation, MeasurementNode statusNode) { Map<String, OperationPerfGroup> statusMap = operationPerfGroups .getGroups() .computeIfAbsent(transport, tn -> new HashMap<>()); OperationPerfGroup group = statusMap .computeIfAbsent(statusNode.getName(), status -> new OperationPerfGroup(transport, status)); OperationPerf operationPerf = createOperationPerf(operation, statusNode); group.addOperationPerf(operationPerf); } private PublishUtils(); static PerfInfo createPerfInfo(MeasurementNode stageNode); static OperationPerf createOperationPerf(String operation, MeasurementNode statusNode); static void addOperationPerfGroups(OperationPerfGroups operationPerfGroups, String transport, String operation,
MeasurementNode statusNode); } | @Test public void addOperationPerfGroups() { OperationPerfGroups groups = new OperationPerfGroups(); PublishUtils.addOperationPerfGroups(groups, Const.RESTFUL, op, Utils.createStatusNode(Status.OK.name(), Utils.totalStageNode)); Map<String, OperationPerfGroup> statusMap = groups.getGroups().get(Const.RESTFUL); OperationPerfGroup group = statusMap.get(Status.OK.name()); PerfInfo perfInfo = group.getSummary().findStage(MeterInvocationConst.STAGE_TOTAL); Integer[] latencyDistribution = group.getSummary().getLatencyDistribution(); Assert.assertEquals(10, perfInfo.getTps(), 0); Assert.assertEquals(1000, perfInfo.calcMsLatency(), 0); Assert.assertEquals(100000, perfInfo.getMsMaxLatency(), 0); Assert.assertEquals(2, latencyDistribution.length); Assert.assertEquals(1, latencyDistribution[0].intValue()); Assert.assertEquals(2, latencyDistribution[1].intValue()); } |
TransportClientConfig { public static int getMaxWaitQueueSize() { return DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.client.maxWaitQueueSize", HttpClientOptions.DEFAULT_MAX_WAIT_QUEUE_SIZE) .get(); } private TransportClientConfig(); static Class<? extends RestTransportClient> getRestTransportClientCls(); static void setRestTransportClientCls(Class<? extends RestTransportClient> restTransportClientCls); static int getThreadCount(); static int getHttp2ConnectionMaxPoolSize(); static int getHttp2MultiplexingLimit(); static int getHttp2ConnectionIdleTimeoutInSeconds(); static boolean getUseAlpn(); static boolean isHttp2TransportClientEnabled(); static int getConnectionMaxPoolSize(); static int getConnectionIdleTimeoutInSeconds(); static boolean getConnectionKeepAlive(); static boolean getConnectionCompression(); static int getMaxHeaderSize(); static int getMaxWaitQueueSize(); static boolean isHttpTransportClientEnabled(); static int getConnectionTimeoutInMillis(); } | @Test public void getMaxWaitQueueSize() { Assert.assertEquals(-1, TransportClientConfig.getMaxWaitQueueSize()); ArchaiusUtils.setProperty("servicecomb.rest.client.maxWaitQueueSize", 1024); Assert.assertEquals(1024, TransportClientConfig.getMaxWaitQueueSize()); } |
RestTransportClient { public void send(Invocation invocation, AsyncResponse asyncResp) { HttpClientWithContext httpClientWithContext = findHttpClientPool(invocation); RestClientInvocation restClientInvocation = new RestClientInvocation(httpClientWithContext, httpClientFilters); try { restClientInvocation.invoke(invocation, asyncResp); } catch (Throwable e) { asyncResp.fail(invocation.getInvocationType(), e); LOGGER.error("vertx rest transport send error.", e); } } void init(Vertx vertx); void send(Invocation invocation, AsyncResponse asyncResp); } | @Test public void testRestTransportClientException() { boolean status = true; Mockito.when(invocation.getOperationMeta()).thenReturn(operationMeta); Mockito.when(operationMeta.getExtData(RestConst.SWAGGER_REST_OPERATION)).thenReturn(operationMeta); try { instance.send(invocation, asyncResp); } catch (Exception e) { status = false; } Assert.assertFalse(status); } |
TransportConfig { public static String getAddress() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty("servicecomb.rest.address", null); return address.get(); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testGetAddressNull() { Assert.assertNull(TransportConfig.getAddress()); }
@Test public void testGetAddressNormal() { ArchaiusUtils.setProperty("servicecomb.rest.address", "1.1.1.1"); Assert.assertEquals("1.1.1.1", TransportConfig.getAddress()); } |
TransportConfig { public static int getThreadCount() { return TransportConfigUtils.readVerticleCount( "servicecomb.rest.server.verticle-count", "servicecomb.rest.server.thread-count"); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testGetThreadCountNull() { new MockUp<Runtime>() { @Mock int availableProcessors() { return 1; } }; Assert.assertEquals(1, TransportConfig.getThreadCount()); }
@Test public void testGetThreadCountNormal() { ArchaiusUtils.setProperty("servicecomb.rest.server.thread-count", 10); Assert.assertEquals(10, TransportConfig.getThreadCount()); } |
TransportConfig { public static boolean isCorsEnabled() { return DynamicPropertyFactory.getInstance() .getBooleanProperty(SERVICECOMB_CORS_CONFIG_BASE + ".enabled", false) .get(); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testIsCorsEnabled() { Assert.assertFalse(TransportConfig.isCorsEnabled()); ArchaiusUtils.setProperty("servicecomb.cors.enabled", true); Assert.assertTrue(TransportConfig.isCorsEnabled()); ArchaiusUtils.setProperty("servicecomb.cors.enabled", false); Assert.assertFalse(TransportConfig.isCorsEnabled()); } |
TransportConfig { public static String getCorsAllowedOrigin() { return DynamicPropertyFactory.getInstance() .getStringProperty(SERVICECOMB_CORS_CONFIG_BASE + ".origin", "*") .get(); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testGetCorsAllowedOrigin() { Assert.assertEquals("*", TransportConfig.getCorsAllowedOrigin()); String origin = "http: ArchaiusUtils.setProperty("servicecomb.cors.origin", origin); Assert.assertEquals(origin, TransportConfig.getCorsAllowedOrigin()); } |
TransportConfig { public static boolean isCorsAllowCredentials() { return DynamicPropertyFactory.getInstance() .getBooleanProperty(SERVICECOMB_CORS_CONFIG_BASE + ".allowCredentials", false) .get(); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testIsCorsAllowCredentials() { Assert.assertFalse(TransportConfig.isCorsAllowCredentials()); ArchaiusUtils.setProperty("servicecomb.cors.allowCredentials", true); Assert.assertTrue(TransportConfig.isCorsAllowCredentials()); ArchaiusUtils.setProperty("servicecomb.cors.allowCredentials", false); Assert.assertFalse(TransportConfig.isCorsAllowCredentials()); } |
TransportConfig { public static Set<String> getCorsAllowedHeaders() { String allowedHeaders = DynamicPropertyFactory.getInstance() .getStringProperty(SERVICECOMB_CORS_CONFIG_BASE + ".allowedHeader", null) .get(); return convertToSet(allowedHeaders); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testGetCorsAllowedHeaders() { String configKey = "servicecomb.cors.allowedHeader"; Assert.assertTrue(TransportConfig.getCorsAllowedHeaders().isEmpty()); ArchaiusUtils.setProperty(configKey, "abc"); Assert.assertThat(TransportConfig.getCorsAllowedHeaders(), Matchers.containsInAnyOrder("abc")); ArchaiusUtils.setProperty(configKey, "abc, def"); Assert.assertThat(TransportConfig.getCorsAllowedHeaders(), Matchers.containsInAnyOrder("abc", "def")); ArchaiusUtils.setProperty(configKey, "abc ,, def"); Assert.assertThat(TransportConfig.getCorsAllowedHeaders(), Matchers.containsInAnyOrder("abc", "def")); ArchaiusUtils.setProperty(configKey, ""); Assert.assertTrue(TransportConfig.getCorsAllowedHeaders().isEmpty()); } |
HealthBootListener implements BootListener { @Override public void onBeforeProducerProvider(BootEvent event) { if (!DynamicPropertyFactory.getInstance().getBooleanProperty("servicecomb.health.endpoint.enabled", true).get()) { return; } event.getScbEngine().getProducerProviderManager() .addProducerMeta("healthEndpoint", new HealthCheckerRestPublisher()); } @Override void onBeforeProducerProvider(BootEvent event); } | @Test public void onBeforeProducerProvider_health_endpoint_enabled_by_default() { final HealthBootListener listener = new HealthBootListener(); final List<ProducerMeta> producerMetas = new ArrayList<>(); final BootEvent event = new BootEvent(); final ProducerMeta producerMeta = new ProducerMeta(); final SCBEngine scbEngine = new SCBEngine() { final public ProducerProviderManager producerProviderManager = new ProducerProviderManager(this) { @Override public void addProducerMeta(String schemaId, Object instance) { producerMeta.setSchemaId(schemaId); producerMeta.setInstance(instance); producerMetas.add(producerMeta); } }; @Override public ProducerProviderManager getProducerProviderManager() { return producerProviderManager; } }; event.setScbEngine(scbEngine); listener.onBeforeProducerProvider(event); Assert.assertThat(producerMetas, Matchers.contains(producerMeta)); Assert.assertThat(producerMeta.getSchemaId(), Matchers.equalTo("healthEndpoint")); Assert.assertThat(producerMeta.getInstance(), Matchers.instanceOf(HealthCheckerRestPublisher.class)); }
@Test public void onBeforeProducerProvider_health_endpoint_disabled() { ArchaiusUtils.setProperty("servicecomb.health.endpoint.enabled", false); final HealthBootListener listener = new HealthBootListener(); final List<ProducerMeta> producerMetas = new ArrayList<>(); final BootEvent event = new BootEvent(); final SCBEngine scbEngine = new SCBEngine() { final public ProducerProviderManager producerProviderManager = new ProducerProviderManager(this) { @Override public void addProducerMeta(String schemaId, Object instance) { producerMetas.add(new ProducerMeta(schemaId, instance)); } }; @Override public ProducerProviderManager getProducerProviderManager() { return producerProviderManager; } }; event.setScbEngine(scbEngine); listener.onBeforeProducerProvider(event); Assert.assertThat(producerMetas, Matchers.empty()); } |
TransportConfig { public static Set<String> getCorsAllowedMethods() { String allowedMethods = DynamicPropertyFactory.getInstance() .getStringProperty(SERVICECOMB_CORS_CONFIG_BASE + ".allowedMethod", null) .get(); return convertToSet(allowedMethods); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testGetCorsAllowedMethods() { String configKey = "servicecomb.cors.allowedMethod"; Assert.assertTrue(TransportConfig.getCorsAllowedMethods().isEmpty()); ArchaiusUtils.setProperty(configKey, "GET"); Assert.assertThat(TransportConfig.getCorsAllowedMethods(), Matchers.containsInAnyOrder("GET")); ArchaiusUtils.setProperty(configKey, "GET, POST"); Assert.assertThat(TransportConfig.getCorsAllowedMethods(), Matchers.containsInAnyOrder("GET", "POST")); ArchaiusUtils.setProperty(configKey, "GET,,POST"); Assert.assertThat(TransportConfig.getCorsAllowedMethods(), Matchers.containsInAnyOrder("GET", "POST")); ArchaiusUtils.setProperty(configKey, ""); Assert.assertTrue(TransportConfig.getCorsAllowedMethods().isEmpty()); } |
TransportConfig { public static Set<String> getCorsExposedHeaders() { String exposedHeaders = DynamicPropertyFactory.getInstance() .getStringProperty(SERVICECOMB_CORS_CONFIG_BASE + ".exposedHeader", null) .get(); return convertToSet(exposedHeaders); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testGetCorsExposedHeaders() { String configKey = "servicecomb.cors.exposedHeader"; Assert.assertTrue(TransportConfig.getCorsExposedHeaders().isEmpty()); ArchaiusUtils.setProperty(configKey, "abc"); Assert.assertThat(TransportConfig.getCorsExposedHeaders(), Matchers.containsInAnyOrder("abc")); ArchaiusUtils.setProperty(configKey, "abc, def"); Assert.assertThat(TransportConfig.getCorsExposedHeaders(), Matchers.containsInAnyOrder("abc", "def")); ArchaiusUtils.setProperty(configKey, "abc ,, def"); Assert.assertThat(TransportConfig.getCorsExposedHeaders(), Matchers.containsInAnyOrder("abc", "def")); ArchaiusUtils.setProperty(configKey, ""); Assert.assertTrue(TransportConfig.getCorsExposedHeaders().isEmpty()); } |
TransportConfig { public static int getCorsMaxAge() { return DynamicPropertyFactory.getInstance() .getIntProperty(SERVICECOMB_CORS_CONFIG_BASE + ".maxAge", -1) .get(); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testGetCorsMaxAge() { Assert.assertEquals(-1, TransportConfig.getCorsMaxAge()); ArchaiusUtils.setProperty("servicecomb.cors.maxAge", 3600); Assert.assertEquals(3600, TransportConfig.getCorsMaxAge()); } |
TransportConfig { public static long getMaxConcurrentStreams() { return DynamicPropertyFactory.getInstance() .getLongProperty("servicecomb.rest.server.http2.concurrentStreams", HttpServerOptions.DEFAULT_INITIAL_SETTINGS_MAX_CONCURRENT_STREAMS) .get(); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testMaxConcurrentStreams() { Assert.assertEquals(100L, TransportConfig.getMaxConcurrentStreams()); ArchaiusUtils.setProperty("servicecomb.rest.server.http2.concurrentStreams", 200L); Assert.assertEquals(200L, TransportConfig.getMaxConcurrentStreams()); } |
TransportConfig { public static boolean getUseAlpn() { return DynamicPropertyFactory.getInstance() .getBooleanProperty("servicecomb.rest.server.http2.useAlpnEnabled", true) .get(); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testUseAlpn() { Assert.assertTrue(TransportConfig.getUseAlpn()); ArchaiusUtils.setProperty("servicecomb.rest.server.http2.useAlpnEnabled", false); Assert.assertFalse(TransportConfig.getUseAlpn()); } |
TransportConfig { public static int getMaxInitialLineLength() { return DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.maxInitialLineLength", HttpServerOptions.DEFAULT_MAX_INITIAL_LINE_LENGTH) .get(); } private TransportConfig(); static Class<? extends Verticle> getRestServerVerticle(); static void setRestServerVerticle(Class<? extends Verticle> restServerVerticle); static String getAddress(); static int getThreadCount(); static int getConnectionIdleTimeoutInSeconds(); static boolean getCompressed(); static long getMaxConcurrentStreams(); static boolean getUseAlpn(); static int getMaxHeaderSize(); static boolean isCorsEnabled(); static String getCorsAllowedOrigin(); static boolean isCorsAllowCredentials(); static Set<String> getCorsAllowedHeaders(); static Set<String> getCorsAllowedMethods(); static Set<String> getCorsExposedHeaders(); static int getCorsMaxAge(); static int getMaxInitialLineLength(); static final int DEFAULT_SERVER_CONNECTION_IDLE_TIMEOUT_SECOND; static final boolean DEFAULT_SERVER_COMPRESSION_SUPPORT; static final int DEFAULT_SERVER_MAX_HEADER_SIZE; static final String SERVICECOMB_CORS_CONFIG_BASE; } | @Test public void testGetMaxInitialLineLength() { Assert.assertEquals(4096, TransportConfig.getMaxInitialLineLength()); ArchaiusUtils.setProperty("servicecomb.rest.server.maxInitialLineLength", 8000); Assert.assertEquals(8000, TransportConfig.getMaxInitialLineLength()); } |
VertxRestTransport extends AbstractTransport { @Override public String getName() { return Const.RESTFUL; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); } | @Test public void testGetName() { Assert.assertEquals("rest", instance.getName()); } |
VertxRestTransport extends AbstractTransport { @Override public boolean init() throws Exception { restClient = RestTransportClientManager.INSTANCE.getRestClient(); DeploymentOptions options = new DeploymentOptions().setInstances(TransportConfig.getThreadCount()); SimpleJsonObject json = new SimpleJsonObject(); json.put(ENDPOINT_KEY, getEndpoint()); json.put(RestTransportClient.class.getName(), restClient); options.setConfig(json); options.setWorkerPoolName("pool-worker-transport-rest"); options.setWorkerPoolSize(VertxOptions.DEFAULT_WORKER_POOL_SIZE); return VertxUtils.blockDeploy(transportVertx, TransportConfig.getRestServerVerticle(), options); } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); } | @Test public void testInit() { boolean status = false; try { new MockUp<VertxUtils>() { @Mock public Vertx init(VertxOptions vertxOptions) { return null; } @Mock public <VERTICLE extends AbstractVerticle> boolean blockDeploy(Vertx vertx, Class<VERTICLE> cls, DeploymentOptions options) throws InterruptedException { return true; } }; instance.init(); } catch (Exception e) { status = true; } Assert.assertFalse(status); } |
VertxRestTransport extends AbstractTransport { @Override public void send(Invocation invocation, AsyncResponse asyncResp) throws Exception { restClient.send(invocation, asyncResp); } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); } | @Test public void testSendException() { boolean validAssert; Invocation invocation = Mockito.mock(Invocation.class); AsyncResponse asyncResp = Mockito.mock(AsyncResponse.class); URIEndpointObject endpoint = Mockito.mock(URIEndpointObject.class); Endpoint end = Mockito.mock(Endpoint.class); Mockito.when(invocation.getEndpoint()).thenReturn(end); Mockito.when(invocation.getEndpoint().getAddress()).thenReturn(endpoint); try { validAssert = true; instance.send(invocation, asyncResp); } catch (Exception e) { validAssert = false; } Assert.assertFalse(validAssert); } |
VertxRestTransport extends AbstractTransport { @Override public int getOrder() { return -1000; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); } | @Test public void testGetOrder() { VertxRestTransport transport = new VertxRestTransport(); Assert.assertEquals(-1000, transport.getOrder()); } |
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); } | @Test public void testCanInitNullAddress() throws IOException { new Expectations(TransportConfig.class) { { TransportConfig.getAddress(); result = null; } }; VertxRestTransport transport = new VertxRestTransport(); Assert.assertTrue(transport.canInit()); }
@Test public void testCanInitListened() throws IOException { ServerSocket ss = new ServerSocket(0); int port = ss.getLocalPort(); new Expectations(TransportConfig.class) { { TransportConfig.getAddress(); result = "0.0.0.0:" + port; } }; VertxRestTransport transport = new VertxRestTransport(); Assert.assertFalse(transport.canInit()); ss.close(); }
@Test public void testCanInitNotListened() throws IOException { ServerSocket ss = new ServerSocket(0); int port = ss.getLocalPort(); ss.close(); new Expectations(TransportConfig.class) { { TransportConfig.getAddress(); result = "0.0.0.0:" + port; } }; VertxRestTransport transport = new VertxRestTransport(); Assert.assertTrue(transport.canInit()); } |
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } } | @Test public void createBodyHandlerUploadNull() { AbstractVertxHttpDispatcher dispatcher = new AbstractVertxHttpDispatcherForTest(); RestBodyHandler bodyHandler = (RestBodyHandler) dispatcher.createBodyHandler(); Assert.assertTrue(Deencapsulation.getField(bodyHandler, "deleteUploadedFilesOnEnd")); Assert.assertNull(Deencapsulation.getField(bodyHandler, "uploadsDir")); }
@Test public void createBodyHandlerUploadNormal() { config.setProperty("servicecomb.uploads.directory", "/path"); AbstractVertxHttpDispatcher dispatcher = new AbstractVertxHttpDispatcherForTest(); RestBodyHandler bodyHandler = (RestBodyHandler) dispatcher.createBodyHandler(); Assert.assertTrue(Deencapsulation.getField(bodyHandler, "deleteUploadedFilesOnEnd")); Assert.assertEquals("/path", Deencapsulation.getField(bodyHandler, "uploadsDir")); } |
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); } | @Test public void testStartFutureAddressEmpty() { boolean status = false; try { instance.start(startFuture); } catch (Exception ex) { status = true; } Assert.assertFalse(status); }
@Test public void testStartFutureAddressNotEmpty() { boolean status = false; MockForRestServerVerticle.getInstance().mockTransportConfig(); MockForRestServerVerticle.getInstance().mockRestServerVerticle(); try { instance.start(startFuture); } catch (Exception ex) { status = true; } Assert.assertFalse(status); } |
RestServerVerticle extends AbstractVerticle { void mountCorsHandler(Router mainRouter) { if (!TransportConfig.isCorsEnabled()) { return; } CorsHandler corsHandler = getCorsHandler(TransportConfig.getCorsAllowedOrigin()); corsHandler.allowCredentials(TransportConfig.isCorsAllowCredentials()); corsHandler.allowedHeaders(TransportConfig.getCorsAllowedHeaders()); Set<String> allowedMethods = TransportConfig.getCorsAllowedMethods(); for (String method : allowedMethods) { corsHandler.allowedMethod(HttpMethod.valueOf(method)); } corsHandler.exposedHeaders(TransportConfig.getCorsExposedHeaders()); int maxAge = TransportConfig.getCorsMaxAge(); if (maxAge >= 0) { corsHandler.maxAgeSeconds(maxAge); } LOGGER.info("mount CorsHandler"); mainRouter.route().handler(corsHandler); } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); } | @Test public void testMountCorsHandler() { ArchaiusUtils.setProperty("servicecomb.cors.enabled", true); ArchaiusUtils.setProperty("servicecomb.cors.allowedMethod", "GET,PUT,POST"); ArchaiusUtils.setProperty("servicecomb.cors.allowedHeader", "abc,def"); ArchaiusUtils.setProperty("servicecomb.cors.exposedHeader", "abc2,def2"); ArchaiusUtils.setProperty("servicecomb.cors.maxAge", 1); Set<HttpMethod> methodSet = new HashSet<>(3); methodSet.add(HttpMethod.GET); methodSet.add(HttpMethod.PUT); methodSet.add(HttpMethod.POST); AtomicInteger counter = new AtomicInteger(0); CorsHandler corsHandler = new MockUp<CorsHandler>() { @Mock CorsHandler allowCredentials(boolean allow) { Assert.assertFalse(allow); counter.incrementAndGet(); return null; } @Mock CorsHandler allowedHeaders(Set<String> headerNames) { Assert.assertThat(headerNames, Matchers.containsInAnyOrder("abc", "def")); counter.incrementAndGet(); return null; } @Mock CorsHandler exposedHeaders(Set<String> headerNames) { Assert.assertThat(headerNames, Matchers.containsInAnyOrder("abc2", "def2")); counter.incrementAndGet(); return null; } @Mock CorsHandler allowedMethod(HttpMethod method) { Assert.assertTrue(methodSet.contains(method)); counter.incrementAndGet(); methodSet.remove(method); return null; } @Mock CorsHandler maxAgeSeconds(int maxAgeSeconds) { Assert.assertEquals(1, maxAgeSeconds); counter.incrementAndGet(); return null; } }.getMockInstance(); new MockUp<RestServerVerticle>() { @Mock CorsHandler getCorsHandler(String corsAllowedOrigin) { Assert.assertEquals("*", corsAllowedOrigin); return corsHandler; } }; Router router = Mockito.mock(Router.class); Mockito.when(router.route()).thenReturn(Mockito.mock(Route.class)); RestServerVerticle server = new RestServerVerticle(); Deencapsulation.invoke(server, "mountCorsHandler", router); Assert.assertEquals(7, counter.get()); } |
RestServerVerticle extends AbstractVerticle { private void mountGlobalRestFailureHandler(Router mainRouter) { GlobalRestFailureHandler globalRestFailureHandler = SPIServiceUtils.getPriorityHighestService(GlobalRestFailureHandler.class); Handler<RoutingContext> failureHandler = null == globalRestFailureHandler ? ctx -> { if (ctx.response().closed() || ctx.response().ended()) { LOGGER.error("get a failure with closed response", ctx.failure()); return; } HttpServerResponse response = ctx.response(); if (ctx.failure() instanceof InvocationException) { InvocationException exception = (InvocationException) ctx.failure(); response.setStatusCode(exception.getStatusCode()); response.setStatusMessage(exception.getReasonPhrase()); response.end(exception.getErrorData().toString()); return; } LOGGER.error("unexpected failure happened", ctx.failure()); try { CommonExceptionData unknownError = new CommonExceptionData("unknown error"); ctx.response().setStatusCode(500).putHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON) .end(RestObjectMapperFactory.getRestObjectMapper().writeValueAsString(unknownError)); } catch (Exception e) { LOGGER.error("failed to send error response!", e); } } : globalRestFailureHandler; mainRouter.route() .handler(RoutingContext::next) .failureHandler(failureHandler); } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); } | @Test public void mountGlobalRestFailureHandler() { Router mainRouter = Mockito.mock(Router.class); Holder<Handler<RoutingContext>> handlerHolder = new Holder<>(); Holder<Route> routeHolder = new Holder<>(); Route route = new MockUp<Route>() { @Mock Route failureHandler(Handler<RoutingContext> failureHandler) { handlerHolder.value = failureHandler; return null; } @Mock Route handler(io.vertx.core.Handler<io.vertx.ext.web.RoutingContext> requestHandler) { return routeHolder.value; } }.getMockInstance(); routeHolder.value = route; Mockito.when(mainRouter.route()).thenReturn(route); RestServerVerticle restServerVerticle = new RestServerVerticle(); Deencapsulation.invoke(restServerVerticle, "mountGlobalRestFailureHandler", mainRouter); Assert.assertNotNull(handlerHolder.value); RoutingContext routingContext = Mockito.mock(RoutingContext.class); HttpServerResponse response = Mockito.mock(HttpServerResponse.class); Mockito.when(response.setStatusCode(500)).thenReturn(response); Mockito.when(response.putHeader("Content-Type", "application/json")).thenReturn(response); Mockito.when(routingContext.response()).thenReturn(response); handlerHolder.value.handle(routingContext); Mockito.verify(response).end("{\"message\":\"unknown error\"}"); } |
VertxRestDispatcher extends AbstractVertxHttpDispatcher { @Override public int getOrder() { return DynamicPropertyFactory.getInstance().getIntProperty(KEY_ORDER, Integer.MAX_VALUE).get(); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); } | @Test public void getOrder() { Assert.assertEquals(Integer.MAX_VALUE, dispatcher.getOrder()); } |
DefaultRegistryInitializer implements MetricsInitializer { @Override @SuppressWarnings("deprecation") public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; System.setProperty("spectator.api.gaugePollingFrequency", Duration.ofMillis(config.getMsPollInterval()).toString()); System.setProperty(SERVO_POLLERS, String.valueOf(config.getMsPollInterval())); registry = new com.netflix.spectator.servo.ServoRegistry(); globalRegistry.add(registry); } @Override int getOrder(); @Override @SuppressWarnings("deprecation") void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override void destroy(); static final String SERVO_POLLERS; } | @Test @SuppressWarnings("deprecation") public void init() { registryInitializer.init(globalRegistry, new EventBus(), new MetricsBootstrapConfig()); Assert.assertEquals(-10, registryInitializer.getOrder()); Assert.assertThat(globalRegistry.getDefaultRegistry(), Matchers.instanceOf(com.netflix.spectator.servo.ServoRegistry.class)); Assert.assertEquals(1, registries.size()); Assert.assertEquals(1, DefaultMonitorRegistry.getInstance().getRegisteredMonitors().size()); registryInitializer.destroy(); Assert.assertEquals(0, registries.size()); Assert.assertEquals(0, DefaultMonitorRegistry.getInstance().getRegisteredMonitors().size()); } |
VertxRestDispatcher extends AbstractVertxHttpDispatcher { protected void onRequest(RoutingContext context) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } HttpServletRequestEx requestEx = new VertxServerRequestToHttpServletRequest(context); HttpServletResponseEx responseEx = new VertxServerResponseToHttpServletResponse(context.response()); if (SCBEngine.getInstance().isFilterChainEnabled()) { InvocationCreator creator = new RestVertxProducerInvocationCreator(context, microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } VertxRestInvocation vertxRestInvocation = new VertxRestInvocation(); context.put(RestConst.REST_PRODUCER_INVOCATION, vertxRestInvocation); vertxRestInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); } | @Test public void onRequest(@Mocked Vertx vertx, @Mocked Context context, @Mocked HttpServerRequest request, @Mocked SocketAddress socketAdrress) { Map<String, Object> map = new HashMap<>(); RoutingContext routingContext = new MockUp<RoutingContext>() { @Mock RoutingContext put(String key, Object obj) { map.put(key, obj); return null; } @Mock HttpServerRequest request() { return request; } }.getMockInstance(); new Expectations() { { Vertx.currentContext(); result = context; } }; Deencapsulation.invoke(dispatcher, "onRequest", routingContext); Assert.assertEquals(VertxRestInvocation.class, map.get(RestConst.REST_PRODUCER_INVOCATION).getClass()); Assert.assertTrue(invoked); } |
VertxRestDispatcher extends AbstractVertxHttpDispatcher { String wrapResponseBody(String message) { if (isValidJson(message)) { return message; } JsonObject jsonObject = new JsonObject(); jsonObject.put("message", message); return jsonObject.toString(); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); } | @Test public void testWrapResponseBody() { VertxRestDispatcher vertxRestDispatcher = new VertxRestDispatcher(); String message = "abcd"; String bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\"abcd\"}", bodyString); message = "\"abcd\""; bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\"\\\"abcd\\\"\"}", bodyString); message = ".01ab\"!@#$%^&*()'\\cd"; bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\".01ab\\\"!@#$%^&*()'\\\\cd\"}", bodyString); message = new JsonObject().put("key", new JsonObject().put("k2", "value")).toString(); bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"key\":{\"k2\":\"value\"}}", bodyString); message = "ab\"23\n@!#cd"; bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\"ab\\\"23\\n@!#cd\"}", bodyString); message = "ab\"23\r\n@!#cd"; bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\"ab\\\"23\\r\\n@!#cd\"}", bodyString); } |
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); } | @Test public void testGetConfigLocationsEmpty() { String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers.arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE)); }
@Test public void testGetConfigLocationsComma() { new Expectations() { { servletContext.getInitParameter(CseXmlWebApplicationContext.KEY_LOCATION); result = "a,b"; } }; String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers .arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE, "a", "b")); }
@Test public void testGetConfigLocationsPartEmpty() { new Expectations() { { servletContext.getInitParameter(CseXmlWebApplicationContext.KEY_LOCATION); result = "a,,b"; } }; String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers .arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE, "a", "b")); }
@Test public void testGetConfigLocationsLine() { new Expectations() { { servletContext.getInitParameter(CseXmlWebApplicationContext.KEY_LOCATION); result = "a\r\nb"; } }; String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers .arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE, "a", "b")); }
@Test public void testGetConfigLocationsMix() { new Expectations() { { servletContext.getInitParameter(CseXmlWebApplicationContext.KEY_LOCATION); result = "a\r\nb,,c"; } }; String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers .arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE, "a", "b", "c")); } |
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { super.invokeBeanFactoryPostProcessors(beanFactory); ServletUtils.init(getServletContext()); } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); } | @Test public void testInjectServlet(@Mocked ConfigurableListableBeanFactory beanFactory) { Holder<Boolean> holder = new Holder<>(); new MockUp<RestServletInjector>() { @Mock public Dynamic defaultInject(ServletContext servletContext) { holder.value = true; return null; } }; context.invokeBeanFactoryPostProcessors(beanFactory); Assert.assertTrue(holder.value); } |
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); } | @Test public void testCheckUrlPatternNormal() { ServletUtils.checkUrlPattern("/*"); ServletUtils.checkUrlPattern("/abc/*"); ServletUtils.checkUrlPattern("/abc/def/*"); }
@Test public void testCheckUrlPatternMiddleWideChar() { try { ServletUtils.checkUrlPattern("/abc/*def"); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("only support rule like /* or /path/* or /path1/path2/* and so on.", e.getMessage()); } }
@Test public void testCheckUrlPatternNoWideChar() { try { ServletUtils.checkUrlPattern("/abcdef"); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("only support rule like /* or /path/* or /path1/path2/* and so on.", e.getMessage()); } }
@Test public void testCheckUrlPatternNotStartWithSlash() { try { ServletUtils.checkUrlPattern("abcdef/*"); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("only support rule like /* or /path/* or /path1/path2/* and so on.", e.getMessage()); } } |
DefaultRegistryInitializer implements MetricsInitializer { @Override public void destroy() { if (registry != null) { DefaultMonitorRegistry.getInstance().unregister(registry); globalRegistry.remove(registry); } } @Override int getOrder(); @Override @SuppressWarnings("deprecation") void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override void destroy(); static final String SERVO_POLLERS; } | @Test public void destroy_notInit() { registryInitializer.destroy(); } |
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); } | @Test public void testFilterUrlPatternsNormal() { String urlPattern = "/r1/*"; Collection<String> urlPatterns = Arrays.asList(urlPattern); String[] result = ServletUtils.filterUrlPatterns(urlPatterns); Assert.assertThat(result, Matchers.arrayContaining("/r1/*")); result = ServletUtils.filterUrlPatterns(urlPattern); Assert.assertThat(result, Matchers.arrayContaining("/r1/*")); }
@Test public void testFilterUrlPatternsEmpty() { Collection<String> urlPatterns = Arrays.asList(" ", "\t"); String[] result = ServletUtils.filterUrlPatterns(urlPatterns); Assert.assertThat(result, Matchers.emptyArray()); }
@Test public void testFilterUrlPatternsInvalid() { Collection<String> urlPatterns = Arrays.asList("/abc"); try { ServletUtils.filterUrlPatterns(urlPatterns); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("only support rule like /* or /path/* or /path1/path2/* and so on.", e.getMessage()); } } |
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); } | @Test public void testcollectUrlPatternsNoRestServlet(@Mocked ServletContext servletContext, @Mocked ServletRegistration servletRegistration) { new Expectations() { { servletRegistration.getClassName(); result = "test"; servletContext.getServletRegistrations(); result = Collections.singletonMap("test", servletRegistration); } }; String[] result = ServletUtils.collectUrlPatterns(servletContext, RestServlet.class); Assert.assertThat(result, Matchers.emptyArray()); }
@Test public void testcollectUrlPatternsNormalMapping(@Mocked ServletContext servletContext, @Mocked ServletRegistration r1, @Mocked ServletRegistration r2) { Map<String, ServletRegistration> servletRegistrationMap = new LinkedHashMap<>(); servletRegistrationMap.put("r1", r1); servletRegistrationMap.put("r2", r2); new Expectations() { { r1.getClassName(); result = RestServlet.class.getName(); r1.getMappings(); result = Arrays.asList("/r1/*", "/r1/1/*"); r2.getClassName(); result = RestServlet.class.getName(); servletContext.getServletRegistrations(); result = servletRegistrationMap; } }; String[] result = ServletUtils.collectUrlPatterns(servletContext, RestServlet.class); Assert.assertThat(result, Matchers.arrayContaining("/r1/*", "/r1/1/*")); } |
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); } | @Test public void testSaveUrlPrefixNull(@Mocked ServletContext servletContext) { ClassLoaderScopeContext.clearClassLoaderScopeProperty(); ServletUtils.saveUrlPrefix(servletContext); Assert.assertNull(ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX)); ClassLoaderScopeContext.clearClassLoaderScopeProperty(); }
@Test public void testSaveUrlPrefixNormal(@Mocked ServletContext servletContext, @Mocked ServletRegistration servletRegistration) { ClassLoaderScopeContext.clearClassLoaderScopeProperty(); new Expectations() { { servletContext.getContextPath(); result = "/root"; servletRegistration.getClassName(); result = RestServlet.class.getName(); servletRegistration.getMappings(); result = Arrays.asList("/rest/*"); servletContext.getServletRegistrations(); result = Collections.singletonMap("test", servletRegistration); } }; ServletUtils.saveUrlPrefix(servletContext); Assert.assertThat(ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX), Matchers.is("/root/rest")); ClassLoaderScopeContext.clearClassLoaderScopeProperty(); } |
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); } | @Test public void createUploadDir_relative(@Mocked ServletContext servletContext) throws IOException { File tempDir = Files.createTempDirectory("temp").toFile(); new Expectations() { { servletContext.getAttribute(ServletContext.TEMPDIR); result = tempDir; } }; File expectDir = new File(tempDir, "upload"); Assert.assertFalse(expectDir.exists()); File dir = ServletUtils.createUploadDir(servletContext, "upload"); Assert.assertTrue(expectDir.exists()); Assert.assertEquals(expectDir.getAbsolutePath(), dir.getAbsolutePath()); dir.delete(); Assert.assertFalse(expectDir.exists()); tempDir.delete(); Assert.assertFalse(tempDir.exists()); }
@Test public void createUploadDir_absolute(@Mocked ServletContext servletContext) throws IOException { File tempDir = Files.createTempDirectory("temp").toFile(); File expectDir = new File(tempDir, "upload"); Assert.assertFalse(expectDir.exists()); File dir = ServletUtils.createUploadDir(servletContext, expectDir.getAbsolutePath()); Assert.assertTrue(expectDir.exists()); Assert.assertEquals(expectDir.getAbsolutePath(), dir.getAbsolutePath()); dir.delete(); Assert.assertFalse(expectDir.exists()); tempDir.delete(); Assert.assertFalse(tempDir.exists()); } |
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); static final String MANUAL; static final String AUTO_INTERVAL; } | @Test public void manualTask() throws InterruptedException { ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, 0); CountDownLatch latch = new CountDownLatch(1); eventBus.register(new Object() { @Subscribe public void onChecked(InstanceCacheSummary instanceCacheSummary) { result = instanceCacheSummary; latch.countDown(); } }); task.init(); ArchaiusUtils.setProperty(InstanceCacheCheckTask.MANUAL, UUID.randomUUID().toString()); latch.await(); Assert.assertEquals("{\"status\":null,\"producers\":[],\"timestamp\":0}", Json.encode(result)); }
@Test public void autoTask_normal() throws InterruptedException { ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, 1); CountDownLatch latch = new CountDownLatch(1); eventBus.register(new Object() { @Subscribe public void onChecked(InstanceCacheSummary instanceCacheSummary) { result = instanceCacheSummary; ((ScheduledFuture<?>) Deencapsulation.getField(task, "scheduledFuture")).cancel(false); latch.countDown(); } }); task.init(); latch.await(); Assert.assertNotNull(Deencapsulation.getField(task, "scheduledFuture")); Assert.assertEquals("{\"status\":null,\"producers\":[],\"timestamp\":0}", Json.encode(result)); }
@Test public void autoTask_clearOldTask() { Holder<Boolean> cancelResult = new Holder<>(); ScheduledFuture<?> scheduledFuture = new MockUp<ScheduledFuture<?>>() { @Mock boolean cancel(boolean mayInterruptIfRunning) { cancelResult.value = true; return true; } }.getMockInstance(); ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, 0); Deencapsulation.setField(task, "scheduledFuture", scheduledFuture); task.init(); Assert.assertNull(Deencapsulation.getField(task, "scheduledFuture")); Assert.assertTrue(cancelResult.value); }
@Test public void autoTask_invalidIntervalZero() { ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, 0); task.init(); Assert.assertNull(Deencapsulation.getField(task, "scheduledFuture")); }
@Test public void autoTask_invalidIntervalLessThanZero() { ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, -1); task.init(); Assert.assertNull(Deencapsulation.getField(task, "scheduledFuture")); } |
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); } | @Test public void setServletParameters_notSupportUpload() { ServletUtils.setServletParameters(null); }
@Test public void setServletParameters_supportUpload(@Mocked ServletContext servletContext, @Mocked Dynamic d1, @Mocked ServletRegistration d2) throws IOException { Map<String, ServletRegistration> servletRegistrations = new HashMap<>(); servletRegistrations.put("d1", d1); servletRegistrations.put("d2", d2); new Expectations() { { servletContext.getServletRegistrations(); result = servletRegistrations; d1.getClassName(); result = RestServlet.class.getName(); d2.getClassName(); result = HttpServlet.class.getName(); } }; List<MultipartConfigElement> multipartConfigs = new ArrayList<>(); new MockUp<Dynamic>(d1) { @Mock void setMultipartConfig(MultipartConfigElement multipartConfig) { multipartConfigs.add(multipartConfig); } }; File tempDir = Files.createTempDirectory("temp").toFile(); File uploadDir = new File(tempDir, "upload"); ArchaiusUtils.setProperty(RestConst.UPLOAD_DIR, uploadDir.getAbsolutePath()); ServletUtils.setServletParameters(servletContext); Assert.assertEquals(1, multipartConfigs.size()); MultipartConfigElement multipartConfigElement = multipartConfigs.get(0); Assert.assertEquals(uploadDir.getAbsolutePath(), multipartConfigElement.getLocation()); Assert.assertEquals(-1, multipartConfigElement.getMaxFileSize()); Assert.assertEquals(-1, multipartConfigElement.getMaxRequestSize()); Assert.assertEquals(0, multipartConfigElement.getFileSizeThreshold()); uploadDir.delete(); tempDir.delete(); Assert.assertFalse(tempDir.exists()); } |
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } @Override void onComplete(AsyncEvent event); @Override void onTimeout(AsyncEvent event); @Override void onError(AsyncEvent event); @Override void onStartAsync(AsyncEvent event); } | @Test public void onTimeoutCommitted() throws IOException { committed = true; listener.onTimeout(event); Assert.assertNull(request.getAttribute(RestConst.REST_REQUEST)); Assert.assertFalse(flushed); }
@Test public void onTimeoutNotCommitted() throws IOException { committed = false; listener.onTimeout(event); Assert.assertNull(request.getAttribute(RestConst.REST_REQUEST)); Assert.assertEquals(MediaType.APPLICATION_JSON, contentType); Assert.assertEquals(500, statusCode); Assert.assertTrue(flushed); Assert.assertEquals("{\"message\":\"Timeout when processing the request.\"}", writer.toString()); } |
RestServlet extends HttpServlet { @Override public void init() throws ServletException { super.init(); LOGGER.info("Rest Servlet inited"); } @Override void init(); @Override void service(final HttpServletRequest request, final HttpServletResponse response); } | @Test public void testInit() throws ServletException { restservlet.init(); Assert.assertTrue(true); } |
RestServlet extends HttpServlet { @Override public void service(final HttpServletRequest request, final HttpServletResponse response) { servletRestServer.service(request, response); } @Override void init(); @Override void service(final HttpServletRequest request, final HttpServletResponse response); } | @Test public void testService() { Holder<Boolean> holder = new Holder<>(); ServletRestDispatcher servletRestServer = new MockUp<ServletRestDispatcher>() { @Mock void service(HttpServletRequest request, HttpServletResponse response) { holder.value = true; } }.getMockInstance(); Deencapsulation.setField(restservlet, "servletRestServer", servletRestServer); restservlet.service(null, null); Assert.assertTrue(holder.value); } |
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); } | @Test public void testInitNotPublish(@Mocked RestTransportClient restTransportClient) { new MockUp<RestTransportClientManager>() { @Mock public RestTransportClient getRestTransportClient(boolean sslEnabled) { return restTransportClient; } }; new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = null; } }; Assert.assertTrue(transport.init()); Assert.assertNull(transport.getPublishEndpoint()); }
@Test public void testInitPublishNoUrlPrefix(@Mocked RestTransportClient restTransportClient) { new MockUp<RestTransportClientManager>() { @Mock public RestTransportClient getRestTransportClient(boolean sslEnabled) { return restTransportClient; } }; new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = "1.1.1.1:1234"; } }; Assert.assertTrue(transport.init()); Assert.assertEquals("rest: }
@Test public void testInitPublishWithUrlPrefix(@Mocked RestTransportClient restTransportClient) { new MockUp<RestTransportClientManager>() { @Mock public RestTransportClient getRestTransportClient(boolean sslEnabled) { return restTransportClient; } }; new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = "1.1.1.1:1234"; } }; ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, "/root"); Assert.assertTrue(transport.init()); Assert.assertEquals("rest: } |
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); } | @Test public void testCanInitNullAddress() throws IOException { new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = null; } }; ServletRestTransport transport = new ServletRestTransport(); Assert.assertTrue(transport.canInit()); }
@Test public void testCanInitListened() throws IOException { ServerSocket ss = new ServerSocket(0); int port = ss.getLocalPort(); new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = "0.0.0.0:" + port; } }; ServletRestTransport transport = new ServletRestTransport(); Assert.assertTrue(transport.canInit()); ss.close(); }
@Test public void testCanInitNotListened() throws IOException { ServerSocket ss = new ServerSocket(0); int port = ss.getLocalPort(); ss.close(); new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = "0.0.0.0:" + port; } }; ServletRestTransport transport = new ServletRestTransport(); Assert.assertFalse(transport.canInit()); } |
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } static Dynamic defaultInject(ServletContext servletContext); Dynamic inject(ServletContext servletContext, String urlPattern); static final String SERVLET_NAME; } | @Test public void testDefaultInjectEmptyUrlPattern(@Mocked ServletContext servletContext, @Mocked Dynamic dynamic) { new Expectations(ServletConfig.class) { { ServletConfig.getServletUrlPattern(); result = null; } }; Assert.assertEquals(null, RestServletInjector.defaultInject(servletContext)); }
@Test public void testDefaultInjectNotListen(@Mocked ServletContext servletContext, @Mocked Dynamic dynamic) throws UnknownHostException, IOException { try (ServerSocket ss = new ServerSocket(0, 0, InetAddress.getByName("127.0.0.1"))) { int port = ss.getLocalPort(); new Expectations(ServletConfig.class) { { ServletConfig.getServletUrlPattern(); result = "/*"; ServletConfig.getLocalServerAddress(); result = "127.0.0.1:" + port; } }; } Assert.assertEquals(null, RestServletInjector.defaultInject(servletContext)); }
@Test public void testDefaultInjectListen(@Mocked ServletContext servletContext, @Mocked Dynamic dynamic) throws UnknownHostException, IOException { try (ServerSocket ss = new ServerSocket(0, 0, InetAddress.getByName("127.0.0.1"))) { int port = ss.getLocalPort(); new Expectations(ServletConfig.class) { { ServletConfig.getServletUrlPattern(); result = "/rest/*"; ServletConfig.getLocalServerAddress(); result = "127.0.0.1:" + port; } }; Assert.assertEquals(dynamic, RestServletInjector.defaultInject(servletContext)); } } |
RestServletProducerInvocation extends RestProducerInvocation { @Override protected void findRestOperation() { super.findRestOperation(); boolean cacheRequest = collectCacheRequest(restOperationMeta.getOperationMeta()); ((StandardHttpServletRequestEx) requestEx).setCacheRequest(cacheRequest); } } | @Test public void findRestOperationCacheTrue(@Mocked HttpServletRequest request, @Mocked HttpServerFilter f1) { HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); Deencapsulation.setField(restInvocation, "requestEx", requestEx); new MockUp<RestProducerInvocation>() { @Mock void findRestOperation() { Deencapsulation.setField(getMockInstance(), "restOperationMeta", restOperationMeta); } }; List<HttpServerFilter> httpServerFilters = Arrays.asList(f1); new Expectations() { { f1.needCacheRequest(operationMeta); result = true; } }; restInvocation.setHttpServerFilters(httpServerFilters); restInvocation.findRestOperation(); Assert.assertTrue(Deencapsulation.getField(requestEx, "cacheRequest")); } |
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } } | @Test public void collectCacheRequestCacheTrue(@Mocked HttpServerFilter f1) { List<HttpServerFilter> httpServerFilters = Arrays.asList(f1); new Expectations() { { f1.needCacheRequest(operationMeta); result = true; } }; restInvocation.setHttpServerFilters(httpServerFilters); Assert.assertTrue(restInvocation.collectCacheRequest(operationMeta)); }
@Test public void collectCacheRequestCacheFalse(@Mocked HttpServerFilter f1) { List<HttpServerFilter> httpServerFilters = Arrays.asList(f1); new Expectations() { { f1.needCacheRequest(operationMeta); result = false; } }; restInvocation.setHttpServerFilters(httpServerFilters); Assert.assertFalse(restInvocation.collectCacheRequest(operationMeta)); } |
ServletRestDispatcher { public void service(HttpServletRequest request, HttpServletResponse response) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } AsyncContext asyncCtx = request.startAsync(); asyncCtx.addListener(restAsyncListener); asyncCtx.setTimeout(ServletConfig.getAsyncServletTimeout()); HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); HttpServletResponseEx responseEx = new StandardHttpServletResponseEx(response); if (SCBEngine.getInstance().isFilterChainEnabled()) { ((StandardHttpServletRequestEx) requestEx).setCacheRequest(true); InvocationCreator creator = new RestServletProducerInvocationCreator(microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } RestServletProducerInvocation restProducerInvocation = new RestServletProducerInvocation(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } void service(HttpServletRequest request, HttpServletResponse response); } | @Test public void service() { Holder<Boolean> handled = new Holder<>(); new MockUp<RestServletProducerInvocation>() { @Mock void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx, List<HttpServerFilter> httpServerFilters) { handled.value = true; } }; dispatcher.service(request, response); Assert.assertTrue(handled.value); } |
RestServletContextListener implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent sce) { try { initSpring(sce); } catch (Exception e) { throw new Error(e); } } @Override void contextInitialized(ServletContextEvent sce); AbstractApplicationContext initSpring(ServletContextEvent sce); @Override void contextDestroyed(ServletContextEvent sce); } | @Test public void testcontextInitializedException() { boolean status = true; RestServletContextListener listener = new RestServletContextListener(); ServletContextEvent sce = Mockito.mock(ServletContextEvent.class); try { listener.contextInitialized(sce); } catch (Exception | Error e) { status = false; } Assert.assertFalse(status); } |
RestServletContextListener implements ServletContextListener { public AbstractApplicationContext initSpring(ServletContextEvent sce) { context = new CseXmlWebApplicationContext(sce.getServletContext()); context.refresh(); return context; } @Override void contextInitialized(ServletContextEvent sce); AbstractApplicationContext initSpring(ServletContextEvent sce); @Override void contextDestroyed(ServletContextEvent sce); } | @Test public void testInitSpring() { boolean status = true; RestServletContextListener listener = new RestServletContextListener(); ServletContextEvent sce = Mockito.mock(ServletContextEvent.class); ServletContext context = Mockito.mock(ServletContext.class); Mockito.when(sce.getServletContext()).thenReturn(context); Mockito.when(sce.getServletContext().getInitParameter("contextConfigLocation")).thenReturn("locations"); try { listener.initSpring(sce); } catch (Exception e) { status = false; } Assert.assertFalse(status); } |
ServletConfig { public static String getLocalServerAddress() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(SERVICECOMB_REST_ADDRESS, null); return address.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); static final long DEFAULT_ASYN_SERVLET_TIMEOUT; static final String KEY_SERVLET_URL_PATTERN; static final String SERVICECOMB_REST_ADDRESS; static final String KEY_SERVICECOMB_ASYC_SERVLET_TIMEOUT; static final String DEFAULT_URL_PATTERN; } | @Test public void testGetLocalServerAddress() { Assert.assertNull(ServletConfig.getLocalServerAddress()); } |
ServletConfig { public static long getAsyncServletTimeout() { return asyncServletTimeoutProperty.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); static final long DEFAULT_ASYN_SERVLET_TIMEOUT; static final String KEY_SERVLET_URL_PATTERN; static final String SERVICECOMB_REST_ADDRESS; static final String KEY_SERVICECOMB_ASYC_SERVLET_TIMEOUT; static final String DEFAULT_URL_PATTERN; } | @Test public void testGetServerTimeout() { Assert.assertEquals(ServletConfig.DEFAULT_ASYN_SERVLET_TIMEOUT, ServletConfig.getAsyncServletTimeout()); } |
ServletConfig { public static String getServletUrlPattern() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(KEY_SERVLET_URL_PATTERN, null); return address.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); static final long DEFAULT_ASYN_SERVLET_TIMEOUT; static final String KEY_SERVLET_URL_PATTERN; static final String SERVICECOMB_REST_ADDRESS; static final String KEY_SERVICECOMB_ASYC_SERVLET_TIMEOUT; static final String DEFAULT_URL_PATTERN; } | @Test public void testGetServletUrlPattern() { DynamicPropertyFactory.getInstance(); Configuration configuration = (Configuration) DynamicPropertyFactory.getBackingConfigurationSource(); configuration.setProperty(ServletConfig.KEY_SERVLET_URL_PATTERN, "/*"); Assert.assertEquals("/*", ServletConfig.getServletUrlPattern()); } |
CseRestTemplate extends AcceptableRestTemplate { public CseRestTemplate() { setMessageConverters(Arrays.asList(new CseHttpMessageConverter())); setRequestFactory(new CseClientHttpRequestFactory()); setUriTemplateHandler(new CseUriTemplateHandler()); } CseRestTemplate(); @Override @Nullable T getForObject(String url, Class<T> responseType, Object... uriVariables); @Override @Nullable T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables); @Override @Nullable T getForObject(URI url, Class<T> responseType); @Override @Nullable T postForObject(String url, @Nullable Object request, Class<T> responseType,
Object... uriVariables); @Override @Nullable T postForObject(String url, @Nullable Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override @Nullable T postForObject(URI url, @Nullable Object request, Class<T> responseType); @Override @Nullable T patchForObject(String url, @Nullable Object request, Class<T> responseType,
Object... uriVariables); @Override @Nullable T patchForObject(String url, @Nullable Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override @Nullable T patchForObject(URI url, @Nullable Object request, Class<T> responseType); @Override ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType); @Override RequestCallback httpEntityCallback(Object requestBody); @Override RequestCallback httpEntityCallback(Object requestBody, Type responseType); @Override boolean isAcceptable(String uri); @Override boolean isAcceptable(URI uri); } | @Test public void testCseRestTemplate() { Assert.assertEquals(CseRestTemplate.class, new CseRestTemplate().getClass()); } |
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public int getOrder() { return Integer.MIN_VALUE; } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); } | @Test public void getOrder() { Assert.assertEquals(Integer.MIN_VALUE, filter.getOrder()); } |
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); } | @Test public void beforeSendRequestNoHeader(@Mocked Invocation invocation) { Map<String, Object> context = new HashMap<>(); new Expectations() { { invocation.getHandlerContext(); result = context; } }; HttpServletRequestEx requestEx = new CommonToHttpServletRequest(null, null, new HttpHeaders(), null, false); filter.beforeSendRequest(invocation, requestEx); Assert.assertFalse(requestEx.getHeaderNames().hasMoreElements()); }
@Test public void beforeSendRequestWithNullHeader(@Mocked Invocation invocation) { Map<String, Object> context = new HashMap<>(1); HttpHeaders httpHeaders = new HttpHeaders(); context.put(RestConst.CONSUMER_HEADER, httpHeaders); httpHeaders.add("headerName0", "headerValue0"); httpHeaders.add("headerName1", null); httpHeaders.add("headerName2", "headerValue2"); new Expectations() { { invocation.getHandlerContext(); result = context; } }; HttpServletRequestEx requestEx = new CommonToHttpServletRequest(null, null, new HttpHeaders(), null, false); filter.beforeSendRequest(invocation, requestEx); Assert.assertEquals("headerValue0", requestEx.getHeader("headerName0")); Assert.assertEquals("headerValue2", requestEx.getHeader("headerName2")); Assert.assertNull(requestEx.getHeader("headerName1")); }
@Test public void beforeSendRequestHaveHeader(@Mocked Invocation invocation) { HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.add("name", "value"); Map<String, Object> context = new HashMap<>(); context.put(RestConst.CONSUMER_HEADER, httpHeaders); new Expectations() { { invocation.getHandlerContext(); result = context; } }; HttpServletRequestEx requestEx = new CommonToHttpServletRequest(null, null, new HttpHeaders(), null, false); filter.beforeSendRequest(invocation, requestEx); Assert.assertThat(Collections.list(requestEx.getHeaders("name")), Matchers.contains("value")); }
@Test public void beforeSendRequestSkipContentLength(@Mocked Invocation invocation) { HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.add(HttpHeaders.CONTENT_LENGTH, "0"); Map<String, Object> context = new HashMap<>(); context.put(RestConst.CONSUMER_HEADER, httpHeaders); new Expectations() { { invocation.getHandlerContext(); result = context; } }; HttpServletRequestEx requestEx = new CommonToHttpServletRequest(null, null, new HttpHeaders(), null, false); filter.beforeSendRequest(invocation, requestEx); Assert.assertNull((requestEx.getHeader(HttpHeaders.CONTENT_LENGTH))); } |
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx) { return null; } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); } | @Test public void afterReceiveResponse() { Assert.assertNull(filter.afterReceiveResponse(null, null)); } |
CseClientHttpRequestFactory implements ClientHttpRequestFactory { @Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException { return new CseClientHttpRequest(uri, httpMethod); } @Override ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod); } | @Test public void testCseClientHttpRequestFactory() { CseClientHttpRequestFactory lCseClientHttpRequestFactory = new CseClientHttpRequestFactory(); try { Assert.assertEquals(HttpMethod.GET, lCseClientHttpRequestFactory.createRequest(URI.create("/test"), HttpMethod.GET).getMethod()); } catch (IOException e) { Assert.assertNotNull(e); } } |
RestTemplateWrapper extends RestTemplate { @Override public HttpHeaders headForHeaders(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).headForHeaders(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void headForHeadersWithUnderlyingRestTemplate() { HttpHeaders expected = new HttpHeaders(); HttpHeaders actual; when(underlying.headForHeaders(url, param1, param2)).thenReturn(expected); actual = wrapper.headForHeaders(url, param1, param2); assertThat(actual, is(expected)); verify(underlying).headForHeaders(url, param1, param2); when(underlying.headForHeaders(url, paramsMap)).thenReturn(expected); actual = wrapper.headForHeaders(url, paramsMap); assertThat(actual, is(expected)); verify(underlying).headForHeaders(url, paramsMap); when(underlying.headForHeaders(uri)).thenReturn(expected); actual = wrapper.headForHeaders(uri); assertThat(actual, is(expected)); verify(underlying).headForHeaders(uri); } |
RestTemplateWrapper extends RestTemplate { @Override public Set<HttpMethod> optionsForAllow(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).optionsForAllow(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void optionsForAllowWithUnderlyingRestTemplate() { Set<HttpMethod> expected = new HashSet<>(this.httpMethods); Set<HttpMethod> actual; when(underlying.optionsForAllow(url, param1, param2)).thenReturn(expected); actual = wrapper.optionsForAllow(url, param1, param2); assertThat(actual, is(expected)); verify(underlying).optionsForAllow(url, param1, param2); when(underlying.optionsForAllow(url, paramsMap)).thenReturn(expected); actual = wrapper.optionsForAllow(url, paramsMap); assertThat(actual, is(expected)); verify(underlying).optionsForAllow(url, paramsMap); when(underlying.optionsForAllow(uri)).thenReturn(expected); actual = wrapper.optionsForAllow(uri); assertThat(actual, is(expected)); verify(underlying).optionsForAllow(uri); } |
RestTemplateWrapper extends RestTemplate { @Override public <T> T getForObject(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForObject(url, responseType, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void getForObjectWithUnderlyingRestTemplate() { String actual; when(underlying.getForObject(url, String.class, param1, param2)).thenReturn(response); actual = wrapper.getForObject(url, String.class, param1, param2); assertThat(actual, is(response)); verify(underlying).getForObject(url, String.class, param1, param2); when(underlying.getForObject(url, String.class, paramsMap)).thenReturn(response); actual = wrapper.getForObject(url, String.class, paramsMap); assertThat(actual, is(response)); verify(underlying).getForObject(url, String.class, paramsMap); when(underlying.getForObject(uri, String.class)).thenReturn(response); actual = wrapper.getForObject(uri, String.class); assertThat(actual, is(response)); verify(underlying).getForObject(uri, String.class); } |
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForEntity(url, responseType, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void getForEntityWithUnderlyingRestTemplate() { ResponseEntity<String> actual; when(underlying.getForEntity(url, String.class, param1, param2)).thenReturn(responseEntity); actual = wrapper.getForEntity(url, String.class, param1, param2); assertThat(actual, is(responseEntity)); verify(underlying).getForEntity(url, String.class, param1, param2); when(underlying.getForEntity(url, String.class, paramsMap)).thenReturn(responseEntity); actual = wrapper.getForEntity(url, String.class, paramsMap); assertThat(actual, is(responseEntity)); verify(underlying).getForEntity(url, String.class, paramsMap); when(underlying.getForEntity(uri, String.class)).thenReturn(responseEntity); actual = wrapper.getForEntity(uri, String.class); assertThat(actual, is(responseEntity)); verify(underlying).getForEntity(uri, String.class); } |
RestTemplateWrapper extends RestTemplate { @Override public <T> T postForObject(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForObject(url, request, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void postForObjectWithUnderlyingRestTemplate() { String actual; when(underlying.postForObject(url, requestEntity, String.class, param1, param2)).thenReturn(response); actual = wrapper.postForObject(url, requestEntity, String.class, param1, param2); assertThat(actual, is(response)); verify(underlying).postForObject(url, requestEntity, String.class, param1, param2); when(underlying.postForObject(url, requestEntity, String.class, paramsMap)).thenReturn(response); actual = wrapper.postForObject(url, requestEntity, String.class, paramsMap); assertThat(actual, is(response)); verify(underlying).postForObject(url, requestEntity, String.class, paramsMap); when(underlying.postForObject(uri, requestEntity, String.class)).thenReturn(response); actual = wrapper.postForObject(uri, requestEntity, String.class); assertThat(actual, is(response)); verify(underlying).postForObject(uri, requestEntity, String.class); } |
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForEntity(url, request, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void postForEntityWithUnderlyingRestTemplate() { ResponseEntity<String> actual; when(underlying.postForEntity(url, requestEntity, String.class, param1, param2)).thenReturn(responseEntity); actual = wrapper.postForEntity(url, requestEntity, String.class, param1, param2); assertThat(actual, is(responseEntity)); verify(underlying).postForEntity(url, requestEntity, String.class, param1, param2); when(underlying.postForEntity(url, requestEntity, String.class, paramsMap)).thenReturn(responseEntity); actual = wrapper.postForEntity(url, requestEntity, String.class, paramsMap); assertThat(actual, is(responseEntity)); verify(underlying).postForEntity(url, requestEntity, String.class, paramsMap); when(underlying.postForEntity(uri, requestEntity, String.class)).thenReturn(responseEntity); actual = wrapper.postForEntity(uri, requestEntity, String.class); assertThat(actual, is(responseEntity)); verify(underlying).postForEntity(uri, requestEntity, String.class); } |
RestTemplateWrapper extends RestTemplate { @Override public URI postForLocation(String url, Object request, Object... urlVariables) throws RestClientException { return getRestTemplate(url).postForLocation(url, request, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void postForLocationWithUnderlyingRestTemplate() { URI actual; when(underlying.postForLocation(url, requestEntity, param1, param2)).thenReturn(uri); actual = wrapper.postForLocation(url, requestEntity, param1, param2); assertThat(actual, is(uri)); verify(underlying).postForLocation(url, requestEntity, param1, param2); when(underlying.postForLocation(url, requestEntity, paramsMap)).thenReturn(uri); actual = wrapper.postForLocation(url, requestEntity, paramsMap); assertThat(actual, is(uri)); verify(underlying).postForLocation(url, requestEntity, paramsMap); when(underlying.postForLocation(uri, requestEntity)).thenReturn(uri); actual = wrapper.postForLocation(uri, requestEntity); assertThat(actual, is(uri)); verify(underlying).postForLocation(uri, requestEntity); } |
RestTemplateWrapper extends RestTemplate { @Override public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Object... urlVariables) throws RestClientException { return getRestTemplate(url).execute(url, method, requestCallback, responseExtractor, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void executeWithUnderlyingRestTemplate() { RequestCallback requestCallback = clientHttpRequest -> { }; ResponseExtractor<ResponseEntity<String>> responseExtractor = clientHttpResponse -> responseEntity; ResponseEntity<String> actual; for (HttpMethod method : httpMethods) { when(underlying.execute(url, method, requestCallback, responseExtractor, param1, param2)) .thenReturn(responseEntity); actual = wrapper.execute(url, method, requestCallback, responseExtractor, param1, param2); assertThat(actual, is(responseEntity)); verify(underlying).execute(url, method, requestCallback, responseExtractor, param1, param2); when(underlying.execute(url, method, requestCallback, responseExtractor, paramsMap)).thenReturn(responseEntity); actual = wrapper.execute(url, method, requestCallback, responseExtractor, paramsMap); assertThat(actual, is(responseEntity)); verify(underlying).execute(url, method, requestCallback, responseExtractor, paramsMap); when(underlying.execute(uri, method, requestCallback, responseExtractor)).thenReturn(responseEntity); actual = wrapper.execute(uri, method, requestCallback, responseExtractor); assertThat(actual, is(responseEntity)); verify(underlying).execute(uri, method, requestCallback, responseExtractor); } } |
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void exchangeWithUnderlyingRestTemplate() { ResponseEntity<String> actual; for (HttpMethod method : httpMethods) { when(underlying.exchange(url, method, requestEntity, String.class, param1, param2)).thenReturn(responseEntity); actual = wrapper.exchange(url, method, requestEntity, String.class, param1, param2); assertThat(actual, is(responseEntity)); verify(underlying).exchange(url, method, requestEntity, String.class, param1, param2); when(underlying.exchange(url, method, requestEntity, String.class, paramsMap)).thenReturn(responseEntity); actual = wrapper.exchange(url, method, requestEntity, String.class, paramsMap); assertThat(actual, is(responseEntity)); verify(underlying).exchange(url, method, requestEntity, String.class, paramsMap); when(underlying.exchange(uri, method, requestEntity, String.class)).thenReturn(responseEntity); actual = wrapper.exchange(uri, method, requestEntity, String.class); assertThat(actual, is(responseEntity)); verify(underlying).exchange(uri, method, requestEntity, String.class); RequestEntity<String> request = new RequestEntity<>(method, uri); when(underlying.exchange(request, String.class)).thenReturn(responseEntity); actual = wrapper.exchange(request, String.class); assertThat(actual, is(responseEntity)); verify(underlying).exchange(request, String.class); } }
@Test public void exchangeUsingParameterizedTypeWithUnderlyingRestTemplate() { ParameterizedTypeReference<List<String>> typeReference = new ParameterizedTypeReference<List<String>>() { }; ResponseEntity<List<String>> actual; for (HttpMethod method : httpMethods) { when(underlying.exchange(url, method, requestEntity, typeReference, param1, param2)).thenReturn(typedResponse); actual = wrapper.exchange(url, method, requestEntity, typeReference, param1, param2); assertThat(actual, is(typedResponse)); verify(underlying).exchange(url, method, requestEntity, typeReference, param1, param2); when(underlying.exchange(url, method, requestEntity, typeReference, paramsMap)).thenReturn(typedResponse); actual = wrapper.exchange(url, method, requestEntity, typeReference, paramsMap); assertThat(actual, is(typedResponse)); verify(underlying).exchange(url, method, requestEntity, typeReference, paramsMap); when(underlying.exchange(uri, method, requestEntity, typeReference)).thenReturn(typedResponse); actual = wrapper.exchange(uri, method, requestEntity, typeReference); assertThat(actual, is(typedResponse)); verify(underlying).exchange(uri, method, requestEntity, typeReference); RequestEntity<String> request = new RequestEntity<>(method, uri); when(underlying.exchange(request, typeReference)).thenReturn(typedResponse); actual = wrapper.exchange(request, typeReference); assertThat(actual, is(typedResponse)); verify(underlying).exchange(request, typeReference); } } |
RestTemplateWrapper extends RestTemplate { @Override public void put(String url, Object request, Object... urlVariables) throws RestClientException { getRestTemplate(url).put(url, request, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void putWithUnderlyingRestTemplate() { wrapper.put(url, requestEntity, param1, param2); verify(underlying).put(url, requestEntity, param1, param2); wrapper.put(url, requestEntity, paramsMap); verify(underlying).put(url, requestEntity, paramsMap); wrapper.put(uri, requestEntity); verify(underlying).put(uri, requestEntity); } |
RestTemplateWrapper extends RestTemplate { @Override public void delete(String url, Object... urlVariables) throws RestClientException { getRestTemplate(url).delete(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void deleteWithUnderlyingRestTemplate() { wrapper.delete(url, param1, param2); verify(underlying).delete(url, param1, param2); wrapper.delete(url, paramsMap); verify(underlying).delete(url, paramsMap); wrapper.delete(uri); verify(underlying).delete(uri); } |
RestTemplateWrapper extends RestTemplate { @Override public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) { super.setInterceptors(interceptors); defaultRestTemplate.setInterceptors(interceptors); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void setInterceptorsWithUnderlying() { ClientHttpRequestInterceptor interceptor1 = mock(ClientHttpRequestInterceptor.class); ClientHttpRequestInterceptor interceptor2 = mock(ClientHttpRequestInterceptor.class); List<ClientHttpRequestInterceptor> interceptors = asList(interceptor1, interceptor2); wrapper.setInterceptors(interceptors); assertThat(wrapper.getInterceptors(), contains(interceptor1, interceptor2)); assertThat(wrapper.defaultRestTemplate.getInterceptors(), contains(interceptor1, interceptor2)); verify(underlying, never()).setInterceptors(interceptors); } |
RestTemplateWrapper extends RestTemplate { @Override public void setRequestFactory(ClientHttpRequestFactory requestFactory) { super.setRequestFactory(requestFactory); defaultRestTemplate.setRequestFactory(requestFactory); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void doNotSetRequestFactoryWithUnderlying() { ClientHttpRequestFactory requestFactory = mock(ClientHttpRequestFactory.class); wrapper.setRequestFactory(requestFactory); assertThat(wrapper.getRequestFactory(), is(requestFactory)); assertThat(wrapper.defaultRestTemplate.getRequestFactory(), is(requestFactory)); verify(underlying, never()).setRequestFactory(requestFactory); } |
RestTemplateWrapper extends RestTemplate { @Override public void setErrorHandler(ResponseErrorHandler errorHandler) { super.setErrorHandler(errorHandler); acceptableRestTemplates.forEach(template -> template.setErrorHandler(errorHandler)); defaultRestTemplate.setErrorHandler(errorHandler); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void setErrorHandlerWithUnderlying() { ResponseErrorHandler errorHandler = mock(ResponseErrorHandler.class); wrapper.setErrorHandler(errorHandler); assertThat(wrapper.getErrorHandler(), is(errorHandler)); assertThat(wrapper.defaultRestTemplate.getErrorHandler(), is(errorHandler)); verify(underlying).setErrorHandler(errorHandler); } |
RestTemplateWrapper extends RestTemplate { @Override public void setDefaultUriVariables(Map<String, ?> defaultUriVariables) { super.setDefaultUriVariables(defaultUriVariables); acceptableRestTemplates.forEach(template -> template.setDefaultUriVariables(defaultUriVariables)); defaultRestTemplate.setDefaultUriVariables(defaultUriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void setDefaultUriVariablesWithUnderlying() { Map<String, Object> uriVariables = new HashMap<>(); wrapper.setDefaultUriVariables(uriVariables); assertThat(defaultUriVariablesOf(wrapper), is(uriVariables)); assertThat(defaultUriVariablesOf(wrapper.defaultRestTemplate), is(uriVariables)); verify(underlying).setDefaultUriVariables(uriVariables); } |
RestTemplateWrapper extends RestTemplate { @Override public void setUriTemplateHandler(UriTemplateHandler handler) { super.setUriTemplateHandler(handler); defaultRestTemplate.setUriTemplateHandler(handler); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void dotNotSetUriTemplateHandlerWithUnderlying() { UriTemplateHandler uriTemplateHandler = mock(UriTemplateHandler.class); wrapper.setUriTemplateHandler(uriTemplateHandler); assertThat(wrapper.getUriTemplateHandler(), is(uriTemplateHandler)); assertThat(wrapper.defaultRestTemplate.getUriTemplateHandler(), is(uriTemplateHandler)); verify(underlying, never()).setUriTemplateHandler(uriTemplateHandler); } |
ServiceRegistryFactory { public static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig, Configuration configuration) { return create(null, serviceRegistryConfig, configuration); } private ServiceRegistryFactory(); static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig,
Configuration configuration); static ServiceRegistry create(EventBus eventBus, ServiceRegistryConfig serviceRegistryConfig,
Configuration configuration); } | @Test public void testGetRemoteRegistryClient(@Mocked ServiceRegistryClientImpl registryClient) { Configuration configuration = ConfigUtil.createLocalConfig(); EventBus eventBus = new EventBus(); ServiceRegistryConfig serviceRegistryConfig = ServiceRegistryConfig.INSTANCE; ServiceRegistry serviceRegistry = ServiceRegistryFactory.create(eventBus, serviceRegistryConfig, configuration); serviceRegistry.init(); ServiceRegistryClient client = serviceRegistry.getServiceRegistryClient(); Assert.assertTrue(client instanceof ServiceRegistryClientImpl); serviceRegistry = ServiceRegistryFactory.create(eventBus, serviceRegistryConfig, configuration); Assert.assertTrue(serviceRegistry instanceof RemoteServiceRegistry); serviceRegistry = LocalServiceRegistryFactory.createLocal(eventBus, serviceRegistryConfig, configuration); serviceRegistry.init(); client = serviceRegistry.getServiceRegistryClient(); Assert.assertTrue(client instanceof LocalServiceRegistryClientImpl); Assert.assertTrue(LocalServiceRegistryFactory.createLocal(eventBus, serviceRegistryConfig, configuration) instanceof LocalServiceRegistry); } |
RestTemplateWrapper extends RestTemplate { @Override public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) { super.setMessageConverters(messageConverters); defaultRestTemplate.setMessageConverters(messageConverters); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @SuppressWarnings("unchecked") @Test public void setMessageConvertersWithUnderlying() { ByteArrayHttpMessageConverter messageConverter = mock(ByteArrayHttpMessageConverter.class); wrapper.setMessageConverters(singletonList(messageConverter)); assertThat(wrapper.getMessageConverters(), contains(messageConverter)); assertThat(wrapper.defaultRestTemplate.getMessageConverters(), contains(messageConverter)); verify(underlying, never()).setMessageConverters(singletonList(messageConverter)); } |
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); } | @Test public void getsAcceptableRestTemplate() { assertThat(wrapper.getRestTemplate(uri), is(underlying)); assertThat(wrapper.getRestTemplate(url), is(underlying)); }
@Test public void getsDefaultRestTemplate() { reset(underlying); assertThat(wrapper.getRestTemplate(uri), is(wrapper.defaultRestTemplate)); assertThat(wrapper.getRestTemplate(url), is(wrapper.defaultRestTemplate)); } |
RequestMeta { public ReferenceConfig getReferenceConfig() { return referenceConfig; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); } | @Test public void testGetReferenceConfig() { ReferenceConfig value = requestmeta.getReferenceConfig(); Assert.assertNotNull(value); } |
RequestMeta { public Map<String, String> getPathParams() { return pathParams; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); } | @Test public void testGetPathParams() { Map<String, String> value = requestmeta.getPathParams(); Assert.assertNotNull(value); } |
RequestMeta { public RestOperationMeta getSwaggerRestOperation() { return swaggerRestOperation; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); } | @Test public void testGetSwaggerRestOperation() { RestOperationMeta value = requestmeta.getSwaggerRestOperation(); Assert.assertNotNull(value); } |
RequestMeta { public OperationMeta getOperationMeta() { return operationMeta; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); } | @Test public void testGetOperationMeta() { Assert.assertNull(requestmeta.getOperationMeta()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.