下面列出了怎么用org.springframework.http.HttpMethod的API类实例代码及写法，或者点击链接到github查看源代码。
@Test
void shouldUsingAuthenticationSteps() {
this.mockRest.expect(requestTo("/auth/aws/login")).andExpect(method(HttpMethod.POST))
.andExpect(jsonPath("$.iam_http_request_method").value("POST"))
.andExpect(jsonPath("$.iam_request_url").exists()).andExpect(jsonPath("$.iam_request_body").exists())
.andExpect(jsonPath("$.iam_request_headers").exists()).andExpect(jsonPath("$.role").value("foo-role"))
.andRespond(withSuccess().contentType(MediaType.APPLICATION_JSON).body(
"{" + "\"auth\":{\"client_token\":\"my-token\", \"renewable\": true, \"lease_duration\": 10}"
+ "}"));
AwsIamAuthenticationOptions options = AwsIamAuthenticationOptions.builder().role("foo-role")
.credentials(new BasicAWSCredentials("foo", "bar")).build();
AuthenticationSteps steps = AwsIamAuthentication.createAuthenticationSteps(options);
AuthenticationStepsExecutor executor = new AuthenticationStepsExecutor(steps, this.restTemplate);
VaultToken login = executor.login();
assertThat(login).isInstanceOf(LoginToken.class);
assertThat(login.getToken()).isEqualTo("my-token");
assertThat(((LoginToken) login).getLeaseDuration()).isEqualTo(Duration.ofSeconds(10));
assertThat(((LoginToken) login).isRenewable()).isTrue();
}
@Test // SPR-14694
public void repeatedAccessToResponseViaResource() {
Resource resource = new ClassPathResource("ludwig.json", this.getClass());
RestTemplate restTemplate = new RestTemplate();
restTemplate.setInterceptors(Collections.singletonList(new ContentInterceptor(resource)));
MockRestServiceServer mockServer = MockRestServiceServer.bindTo(restTemplate)
.ignoreExpectOrder(true)
.bufferContent() // enable repeated reads of response body
.build();
mockServer.expect(requestTo("/composers/42")).andExpect(method(HttpMethod.GET))
.andRespond(withSuccess(resource, MediaType.APPLICATION_JSON));
restTemplate.getForObject("/composers/{id}", Person.class, 42);
mockServer.verify();
}
@Test
void testGetAllTasksByWorkbasketIdWithinSinglePlannedTimeInterval() {
Instant plannedFromInstant = Instant.now().minus(6, ChronoUnit.DAYS);
Instant plannedToInstant = Instant.now().minus(3, ChronoUnit.DAYS);
ResponseEntity<TaskanaPagedModel<TaskSummaryRepresentationModel>> response =
TEMPLATE.exchange(
restHelper.toUrl(Mapping.URL_TASKS)
+ "?workbasket-id=WBI:100000000000000000000000000000000001"
+ "&planned-from="
+ plannedFromInstant
+ "&planned-until="
+ plannedToInstant
+ "&sort-by=planned",
HttpMethod.GET,
restHelper.defaultRequest(),
TASK_SUMMARY_PAGE_MODEL_TYPE);
assertThat(response.getBody()).isNotNull();
assertThat((response.getBody()).getLink(IanaLinkRelations.SELF)).isNotNull();
assertThat(response.getBody().getContent()).hasSize(3);
}
private String getChecksum(String defaultValue, String url,
String version) {
String result = defaultValue;
if (result == null && StringUtils.hasText(url)) {
CloseableHttpClient httpClient = HttpClients.custom()
.setSSLHostnameVerifier(new NoopHostnameVerifier())
.build();
HttpComponentsClientHttpRequestFactory requestFactory
= new HttpComponentsClientHttpRequestFactory();
requestFactory.setHttpClient(httpClient);
url = constructUrl(url, version);
try {
ResponseEntity<String> response
= new RestTemplate(requestFactory).exchange(
url, HttpMethod.GET, null, String.class);
if (response.getStatusCode().equals(HttpStatus.OK)) {
result = response.getBody();
}
}
catch (HttpClientErrorException httpException) {
// no action necessary set result to undefined
logger.debug("Didn't retrieve checksum because", httpException);
}
}
return result;
}
@Override
public Void execute(final ResourceWithMetadata resource, final Params params, final WebScriptResponse res, boolean isReadOnly)
{
final ResourceOperation operation = resource.getMetaData().getOperation(HttpMethod.DELETE);
final WithResponse callBack = new WithResponse(operation.getSuccessStatus(), DEFAULT_JSON_CONTENT,CACHE_NEVER);
// MNT-20308 - allow write transactions for authentication api
RetryingTransactionHelper transHelper = getTransactionHelper(resource.getMetaData().getApi().getName());
transHelper.doInTransaction(
new RetryingTransactionCallback<Void>()
{
@Override
public Void execute() throws Throwable
{
executeAction(resource, params, callBack); //ignore return result
return null;
}
}, false, true);
setResponse(res,callBack);
return null;
}
@Test
public void preflightRequestCredentialsWithOriginWildcard() throws Exception {
this.request.setMethod(HttpMethod.OPTIONS.name());
this.request.addHeader(HttpHeaders.ORIGIN, "https://domain2.com");
this.request.addHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, "GET");
this.request.addHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS, "Header1");
this.conf.addAllowedOrigin("https://domain1.com");
this.conf.addAllowedOrigin("*");
this.conf.addAllowedOrigin("http://domain3.com");
this.conf.addAllowedHeader("Header1");
this.conf.setAllowCredentials(true);
this.processor.processRequest(this.conf, this.request, this.response);
assertTrue(this.response.containsHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN));
assertEquals("https://domain2.com", this.response.getHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN));
assertThat(this.response.getHeaders(HttpHeaders.VARY), contains(HttpHeaders.ORIGIN,
HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS));
assertEquals(HttpServletResponse.SC_OK, this.response.getStatus());
}
private void mockBlogRestTemplateCall(String jsonResponse, String registryHost, String registryPort,
String repository, String digest) {
UriComponents blobUriComponents = UriComponentsBuilder.newInstance()
.scheme("https")
.host(registryHost)
.port(StringUtils.hasText(registryPort) ? registryPort : null)
.path("v2/{repository}/blobs/{digest}")
.build().expand(repository, digest);
when(mockRestTemplate.exchange(
eq(blobUriComponents.toUri()),
eq(HttpMethod.GET),
any(HttpEntity.class),
eq(String.class)))
.thenReturn(new ResponseEntity<>(jsonResponse, HttpStatus.OK));
}
/**
* Define the security that applies to the proxy
*/
@Override
public void configure(HttpSecurity http) throws Exception {
http
.authorizeRequests()
//Allow access to all static resources without authentication
.antMatchers("/","/**/*.html").permitAll()
.anyRequest().authenticated()
.antMatchers(HttpMethod.GET, "/api/user/**","/api/task/**").access("#oauth2.hasScope('read')")
.antMatchers(HttpMethod.OPTIONS, "/api/user/**","/api/task/**").access("#oauth2.hasScope('read')")
.antMatchers(HttpMethod.POST, "/api/user/**","/api/task/**").access("#oauth2.hasScope('write')")
.antMatchers(HttpMethod.PUT, "/api/user/**","/api/task/**").access("#oauth2.hasScope('write')")
.antMatchers(HttpMethod.PATCH, "/api/user/**","/api/task/**").access("#oauth2.hasScope('write')")
.antMatchers(HttpMethod.DELETE, "/api/user/**","/api/task/**").access("#oauth2.hasScope('write')")
.and().csrf().csrfTokenRepository(this.getCSRFTokenRepository())
.and().addFilterAfter(this.createCSRFHeaderFilter(), CsrfFilter.class);
}
public Endpoints endpoints(final EndpointQuery query) throws Exception {
final URL queryFileUrl = Resources.getResource("endpoints.gql");
final String queryString = Resources.readLines(queryFileUrl, StandardCharsets.UTF_8)
.stream()
.filter(it -> !it.startsWith("#"))
.collect(Collectors.joining())
.replace("{serviceId}", query.serviceId());
final ResponseEntity<GQLResponse<Endpoints>> responseEntity = restTemplate.exchange(
new RequestEntity<>(queryString, HttpMethod.POST, URI.create(endpointUrl)),
new ParameterizedTypeReference<GQLResponse<Endpoints>>() {
}
);
if (responseEntity.getStatusCode() != HttpStatus.OK) {
throw new RuntimeException("Response status != 200, actual: " + responseEntity.getStatusCode());
}
return Objects.requireNonNull(responseEntity.getBody()).getData();
}
private synchronized JSONObject getLoginInfoFromApi() {
if (loginInfo != null) {
return loginInfo;
}
Map<String, Object> parameters = Maps.newLinkedHashMap();
parameters.put("username", restCredentials.getUsername());
try {
ResponseEntity<String> response = restTemplate.exchange(LOGIN_INFO_URL, HttpMethod.GET, HttpEntity.EMPTY, String.class, parameters);
if (StringUtils.isBlank(response.getBody())) {
throw new RestApiException("Failed to dynamically determine REST urls with username " + restCredentials.getUsername());
}
this.loginInfo = new JSONObject(response.getBody());
return this.loginInfo;
} catch(RestClientException | JSONException e) {
log.error("Error occurred dynamically determining REST urls with username " + restCredentials.getUsername(), e);
throw new RestApiException("Failed to dynamically determine REST urls with username " + restCredentials.getUsername());
}
}
private Map getTaskDetail(Integer taskId, String user, String ujesAddress, String clusterName) throws TaskNotExistException, ClusterInfoNotConfigException {
String url = getPath(ujesAddress).path(linkisConfig.getStatus()).toString();
url = url.replace("{id}", String.valueOf(taskId));
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.add("Token-User", user);
headers.add("Token-Code", getToken(clusterName));
HttpEntity entity = new HttpEntity<>(headers);
LOGGER.info("Start to get job status from linkis. url: {}, method: {}, body: {}", url, javax.ws.rs.HttpMethod.GET, entity);
Map response = restTemplate.exchange(url, HttpMethod.GET, entity, Map.class).getBody();
LOGGER.info("Succeed to get job status from linkis. response: {}", response);
if (!checkResponse(response)) {
throw new TaskNotExistException("Can not get status of task, task_id : " + taskId);
}
if (((Map)response.get("data")).get("task") == null) {
throw new TaskNotExistException("Job id: " + taskId + " does not exist");
}
return response;
}
@Test
public void testRender() throws Exception {
ConfigView configView = ConfigView.getInstance();
Model configData = new LinkedHashModelFactory().createEmptyModel();
configData.add(RDF.ALT, RDF.TYPE, RDFS.CLASS);
Map<Object, Object> map = new LinkedHashMap<>();
map.put(ConfigView.HEADERS_ONLY, false);
map.put(ConfigView.CONFIG_DATA_KEY, configData);
map.put(ConfigView.FORMAT_KEY, RDFFormat.NTRIPLES);
final MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod(HttpMethod.GET.name());
request.addHeader("Accept", RDFFormat.NTRIPLES.getDefaultMIMEType());
MockHttpServletResponse response = new MockHttpServletResponse();
configView.render(map, request, response);
String ntriplesData = response.getContentAsString();
Model renderedData = Rio.parse(new StringReader(ntriplesData), "", RDFFormat.NTRIPLES);
assertThat(renderedData).isNotEmpty();
}
@Test
public void options() throws ServletException, IOException {
MockHttpServletRequest servletRequest = new MockHttpServletRequest("OPTIONS", "/");
ServerRequest request = new DefaultServerRequest(servletRequest, Collections.singletonList(messageConverter));
ServerResponse response = this.handlerFunction.handle(request);
assertEquals(HttpStatus.OK, response.statusCode());
assertEquals(EnumSet.of(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.OPTIONS), response.headers().getAllow());
MockHttpServletResponse servletResponse = new MockHttpServletResponse();
ModelAndView mav = response.writeTo(servletRequest, servletResponse, this.context);
assertNull(mav);
assertEquals(200, servletResponse.getStatus());
assertEquals("GET,HEAD,OPTIONS", servletResponse.getHeader("Allow"));
byte[] actualBytes = servletResponse.getContentAsByteArray();
assertEquals(0, actualBytes.length);
}
@Test
public void nonAdminUserShouldBeRedirectedToIdm() {
String configsUrl = "http://localhost:" + serverPort + "/flowable-admin/app/rest/server-configs";
HttpHeaders headers = new HttpHeaders();
headers.set(HttpHeaders.COOKIE, rememberMeCookie("user", "test-user-value"));
HttpEntity<?> request = new HttpEntity<>(headers);
ResponseEntity<Object> result = restTemplate.exchange(configsUrl, HttpMethod.GET, request, Object.class);
assertThat(result.getStatusCode())
.as("GET server-configs")
.isEqualTo(HttpStatus.FOUND);
assertThat(result.getHeaders().getFirst(HttpHeaders.LOCATION))
.as("redirect location")
.isEqualTo("http://localhost:8080/flowable-idm/#/login?redirectOnAuthSuccess=true&redirectUrl=" + configsUrl);
}
@Test
public void shouldReturnErrorCreateIuguCustomer() {
IuguCustomer iuguCustomer = IuguCustomer.builder()
.email("[email protected]")
.name("Iugu Customer")
.zipCode("05500-100")
.street("Avenida dos Testes")
.city("São Paulo")
.state("SP")
.build();
HttpEntity<IuguCustomer> request = new HttpEntity<>(iuguCustomer);
ResponseEntity<IuguCustomer> responseEntity = ResponseEntity.badRequest().body(null);
when(restTemplate.exchange("https://api.iugu.com/v1/customers?api_token=b17421313f9a8db907afa7b7047fbcd8",
HttpMethod.POST,
request,
IuguCustomer.class))
.thenReturn(responseEntity);
ServiceResponse<IuguCustomer> response = iuguService.createIuguCustomer(iuguCustomer);
Assert.assertThat(response, hasErrorMessage(IuguService.Validations.IUGU_CUSTOMER_CREATION_ERROR.getCode()));
}
@Test
public void containerImageMetadataResolverWithActiveSSL() throws URISyntaxException {
assertThat(containerImageMetadataResolver).isNotNull();
Map<String, String> labels = containerImageMetadataResolver.getImageLabels("demo.goharbor.io/test/image:1.0.0");
assertThat(labels).containsExactly(Collections.singletonMap("foo", "bar").entrySet().iterator().next());
// Determine the OAuth2 token service entry point.
verify(noSslVerificationContainerRestTemplate)
.exchange(eq(new URI("https://demo.goharbor.io/v2/_catalog")), eq(HttpMethod.GET), any(), eq(Map.class));
// Get authorization token
verify(containerRestTemplate).exchange(
eq(new URI("https://demo.goharbor.io/service/token?service=demo-registry2&scope=repository:test/image:pull")),
eq(HttpMethod.GET), any(), eq(Map.class));
// Get Manifest
verify(containerRestTemplate).exchange(eq(new URI("https://demo.goharbor.io/v2/test/image/manifests/1.0.0")),
eq(HttpMethod.GET), any(), eq(Map.class));
// Get Blobs
verify(containerRestTemplate).exchange(eq(new URI("https://demo.goharbor.io/v2/test/image/blobs/test_digest")),
eq(HttpMethod.GET), any(), eq(String.class));
}
/**
* By default a newly created {@code CorsConfiguration} does not permit any
* cross-origin requests and must be configured explicitly to indicate what
* should be allowed.
* <p>Use this method to flip the initialization model to start with open
* defaults that permit all cross-origin requests for GET, HEAD, and POST
* requests. Note however that this method will not override any existing
* values already set.
* <p>The following defaults are applied if not already set:
* <ul>
* <li>Allow all origins.</li>
* <li>Allow "simple" methods {@code GET}, {@code HEAD} and {@code POST}.</li>
* <li>Allow all headers.</li>
* <li>Set max age to 1800 seconds (30 minutes).</li>
* </ul>
*/
public CorsConfiguration applyPermitDefaultValues() {
if (this.allowedOrigins == null) {
this.allowedOrigins = DEFAULT_PERMIT_ALL;
}
if (this.allowedMethods == null) {
this.allowedMethods = DEFAULT_PERMIT_METHODS;
this.resolvedMethods = DEFAULT_PERMIT_METHODS
.stream().map(HttpMethod::resolve).collect(Collectors.toList());
}
if (this.allowedHeaders == null) {
this.allowedHeaders = DEFAULT_PERMIT_ALL;
}
if (this.maxAge == null) {
this.maxAge = 1800L;
}
return this;
}
@Test
public void testMultiLayerObjectParam_rt() {
MultiLayerObjectParam request = new MultiLayerObjectParam("sss-1", new Date(),
new MultiLayerObjectParam2("sss-2", 12.12, FlattenObjectRequest.createFlattenObjectRequest()));
ResponseEntity<MultiLayerObjectParam> responseEntity = consumers.getSCBRestTemplate()
.exchange("/testMultiLayerObjectParam", HttpMethod.PUT,
new HttpEntity<>(request), MultiLayerObjectParam.class);
assertEquals(request, responseEntity.getBody());
assertEquals(200, responseEntity.getStatusCodeValue());
responseEntity = consumers.getSCBRestTemplate()
.exchange("/testMultiLayerObjectParam", HttpMethod.PUT,
new HttpEntity<>(null), MultiLayerObjectParam.class);
// Highway will not give null return value
Assert.assertTrue(responseEntity.getBody() == null || responseEntity.getBody().getString() == null);
assertEquals(200, responseEntity.getStatusCodeValue());
}
@Override
public void run(String... strings) throws Exception {
System.out.println("\n\n\n start RestTemplate client...");
ResponseEntity<Collection<Restaurant>> exchange
= this.restTemplate.exchange(
"http://restaurant-service/v1/restaurants?name=o",
HttpMethod.GET,
null,
new ParameterizedTypeReference<Collection<Restaurant>>() {
},
(Object) "restaurants");
exchange.getBody().forEach((Restaurant restaurant) -> {
System.out.println("\n\n\n[ " + restaurant.getId() + " " + restaurant.getName() + "]");
});
}
@Test
public void cookies() {
HttpCookie cookie = new HttpCookie("foo", "bar");
MockServerWebExchange exchange = MockServerWebExchange.from(
MockServerHttpRequest.method(HttpMethod.GET, "http://example.com").cookie(cookie));
DefaultServerRequest request = new DefaultServerRequest(exchange, messageReaders);
MultiValueMap<String, HttpCookie> expected = new LinkedMultiValueMap<>();
expected.add("foo", cookie);
assertEquals(expected, request.cookies());
}
@Override
protected ServiceDomainResponse makeServiceCall(ServiceDomainRequest payload)
throws UpstreamServiceTimedOutException, UpstreamServiceFailedException {
MultiValueMap<String, String> urlQueryParams = new LinkedMultiValueMap<>();
String endPoint = Validator.isNotNull(payload.getEndpoint()) ? payload.getEndpoint() : DossierStatisticConfig.get(DossierStatisticConstants.SERVICE_DOMAIN_ENDPOINT);
//LOG.info(endPoint);
// get the params for EE
HashMap<String, String> urlPathSegments = new HashMap<>();
// build the url
String url = buildUrl(endPoint, urlPathSegments, urlQueryParams);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.add(DossierStatisticConstants.GROUP_ID, Long.toString(payload.getGroupId()));
// if (Validator.isNotNull(PropsUtil.get(ServerConfigContants.SERVER_SYNC_KEY))
// && Validator.isNotNull(PropsUtil.get(ServerConfigContants.SERVER_SYNC_SECRET))) {
// setHttpHeadersAuthorization(httpHeaders, PropsUtil.get(ServerConfigContants.SERVER_SYNC_KEY), PropsUtil.get(ServerConfigContants.SERVER_SYNC_SECRET));
// }
// else {
// httpHeaders.add("Authorization", "Basic " + DossierStatisticConfig.get(DossierStatisticConstants.OPENCPS_AUTHENCATION));
// }
if (Validator.isNotNull(payload.getUsername()) && Validator.isNotNull(payload.getPassword())) {
httpHeaders.add("Authorization", "Basic " + Base64.getEncoder().encodeToString((payload.getUsername() + ":" + payload.getPassword()).getBytes()));
System.out.println("HTTP BASIC: " + "Basic " + Base64.getEncoder().encodeToString((payload.getUsername() + ":" + payload.getPassword()).getBytes()));
}
System.out.println("END POINT: " + endPoint);
return executeGenericRestCall(url, HttpMethod.GET, httpHeaders, payload, ServiceDomainResponse.class).getBody();
}
@Override
public List<KeeperInstanceMeta> getAllKeepers() {
try {
ResponseEntity<List<KeeperInstanceMeta>> result = restTemplate.exchange("http://{ip}:{port}/keepers",
HttpMethod.GET, null, keeperInstanceMetaListType,
keeperContainerMeta.getIp(), keeperContainerMeta.getPort());
return result.getBody();
} catch (HttpStatusCodeException ex) {
throw KeeperContainerErrorParser.parseErrorFromHttpException(ex);
}
}
/**
* Customize the response for HttpRequestMethodNotSupportedException.
* <p>This method logs a warning, sets the "Allow" header, and delegates to
* {@link #handleExceptionInternal}.
* @param ex the exception
* @param headers the headers to be written to the response
* @param status the selected response status
* @param request the current request
* @return a {@code ResponseEntity} instance
*/
protected ResponseEntity<Object> handleHttpRequestMethodNotSupported(
HttpRequestMethodNotSupportedException ex, HttpHeaders headers, HttpStatus status, WebRequest request) {
pageNotFoundLogger.warn(ex.getMessage());
Set<HttpMethod> supportedMethods = ex.getSupportedHttpMethods();
if (!CollectionUtils.isEmpty(supportedMethods)) {
headers.setAllow(supportedMethods);
}
return handleExceptionInternal(ex, null, headers, status, request);
}
/**
* Creates a GenericRestCall and returns it as an Rx observable. An observable will be fired
* each time a susbcriber subscribes to it, and multiple subscribers can be attached to a single
* observable.
* @param context the context for caching
* @return an observable returning a RestResults<News[]> object
*/
public static rx.Observable<RestResults<News[]>> getObservableNews(Context context) {
return new GenericRestCall<>(Void.class, News[].class, String.class)
.setUrl(BTC_NEWS_URL)
.setContext(context.getApplicationContext())
.isCacheEnabled(true)
.setCacheTime(30000L)
.setMethodToCall(HttpMethod.GET)
.setAutomaticCacheRefresh(true)
.setReprocessWhenRefreshing(true)
.asObservable();
}
/**
* @param pd
* @return
*/
@Override
public ResponseEntity<String> listStaffPrivileges(IPageData pd) {
Assert.hasLength(pd.getUserId(), "用户未登录请先登录");
JSONObject privilegeInfoObj = JSONObject.parseObject(pd.getReqData());
Assert.jsonObjectHaveKey(privilegeInfoObj, "staffId", "请求报文中未包含员工ID 节点");
ResponseEntity<String> storeInfo = super.getStoreInfo(pd, restTemplate);
if (storeInfo.getStatusCode() != HttpStatus.OK) {
return storeInfo;
}
// 商户返回信息
JSONObject storeInfoObj = JSONObject.parseObject(storeInfo.getBody());
String storeId = storeInfoObj.getString("storeId");
privilegeInfoObj.put("storeId", storeId);
ResponseEntity<String> privilegeGroup = super.callCenterService(restTemplate, pd, "",
ServiceConstant.SERVICE_API_URL + "/api/query.user.privilege?userId=" + privilegeInfoObj.getString("staffId") + "&domain=" + storeInfoObj.getString("storeTypeCd"), HttpMethod.GET);
if (privilegeGroup.getStatusCode() != HttpStatus.OK) {
return privilegeGroup;
}
JSONObject resultObj = JSONObject.parseObject(privilegeGroup.getBody().toString());
JSONArray privileges = resultObj.getJSONArray("privileges");
JSONObject resObj = new JSONObject();
resObj.put("datas", privileges);
return new ResponseEntity<String>(resObj.toJSONString(), HttpStatus.OK);
}
@Test
public void testMultiLayerObjectParam_edge() {
MultiLayerObjectParam request = new MultiLayerObjectParam("sss-1", new Date(),
new MultiLayerObjectParam2("sss-2", 12.12, createFlattenObjectRequest()));
ResponseEntity<MultiLayerObjectParam> responseEntity = consumers.getEdgeRestTemplate()
.exchange("/testMultiLayerObjectParam", HttpMethod.PUT,
new HttpEntity<>(request), MultiLayerObjectParam.class);
Assert.assertEquals(request, responseEntity.getBody());
Assert.assertEquals(200, responseEntity.getStatusCodeValue());
responseEntity = consumers.getEdgeRestTemplate()
.exchange("/testMultiLayerObjectParam", HttpMethod.PUT,
new HttpEntity<>(request), MultiLayerObjectParam.class);
Assert.assertEquals(request, responseEntity.getBody());
Assert.assertEquals(200, responseEntity.getStatusCodeValue());
responseEntity = consumers.getEdgeRestTemplate()
.exchange("/testMultiLayerObjectParam", HttpMethod.PUT,
new HttpEntity<>(null), MultiLayerObjectParam.class);
// highway will not return null object
Assert.assertTrue(responseEntity.getBody() == null || responseEntity.getBody().getString() == null);
Assert.assertEquals(200, responseEntity.getStatusCodeValue());
responseEntity = consumers.getEdgeRestTemplate()
.exchange("/testMultiLayerObjectParam", HttpMethod.PUT,
new HttpEntity<>(null), MultiLayerObjectParam.class);
// highway will not return null object
Assert.assertTrue(responseEntity.getBody() == null || responseEntity.getBody().getString() == null);
Assert.assertEquals(200, responseEntity.getStatusCodeValue());
}
@Test
public void options4Allow() {
Set<HttpMethod> httpMethods = template.optionsForAllow(url());
System.out.println(httpMethods.size());
for(HttpMethod hm : httpMethods) {
System.out.println(hm);
}
}
/**
* Finds Pets by tags
* Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
* <p><b>200</b> - successful operation
* <p><b>400</b> - Invalid tag value
* @param tags Tags to filter by (required)
* @return ResponseEntity<Set<Pet>>
* @throws RestClientException if an error occurs while attempting to invoke the API
*/
@Deprecated
public ResponseEntity<Set<Pet>> findPetsByTagsWithHttpInfo(Set<String> tags) throws RestClientException {
Object postBody = null;
// verify the required parameter 'tags' is set
if (tags == null) {
throw new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Missing the required parameter 'tags' when calling findPetsByTags");
}
String path = apiClient.expandPath("/pet/findByTags", Collections.<String, Object>emptyMap());
final MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<String, String>();
final HttpHeaders headerParams = new HttpHeaders();
final MultiValueMap<String, String> cookieParams = new LinkedMultiValueMap<String, String>();
final MultiValueMap formParams = new LinkedMultiValueMap();
queryParams.putAll(apiClient.parameterToMultiValueMap(ApiClient.CollectionFormat.valueOf("csv".toUpperCase(Locale.ROOT)), "tags", tags));
final String[] accepts = {
"application/xml", "application/json"
};
final List<MediaType> accept = apiClient.selectHeaderAccept(accepts);
final String[] contentTypes = { };
final MediaType contentType = apiClient.selectHeaderContentType(contentTypes);
String[] authNames = new String[] { "petstore_auth" };
ParameterizedTypeReference<Set<Pet>> returnType = new ParameterizedTypeReference<Set<Pet>>() {};
return apiClient.invokeAPI(path, HttpMethod.GET, queryParams, postBody, headerParams, cookieParams, formParams, accept, contentType, authNames, returnType);
}
@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
ClientHttpRequest request = super.createRequest(uri, httpMethod);
request.getHeaders().add("X-OTX-API-KEY",apiKey);
request.getHeaders().add(HttpHeaders.USER_AGENT,SDK_USER_AGENT);
return request;
}
private HttpMessage setupHttpMessage(String path, HttpMethod method, Map<String, String> queryParams) {
final HttpMessage httpMessage = Mockito.mock(HttpMessage.class);
when(httpMessage.getPath()).thenReturn(path);
when(httpMessage.getRequestMethod()).thenReturn(method);
when(httpMessage.getQueryParams()).thenReturn(queryParams);
return httpMessage;
}