/** * Create a broker Instance * * @param brokerName * @return * @throws CloudKarafkaServiceException */ public CloudKarafkaCreateInstanceResponse createInstance(final String brokerName, final String plan) throws CloudKarafkaServiceException { // build input form final MultivaluedMap<String, String> form = new MultivaluedHashMap<>(); form.add("name", brokerName); form.add("plan", plan); form.add("region", brokerConfig.getCloudKarafkaRegion()); //build post request final String target = String.format("%s/%s", brokerConfig.getCloudkarafkaApiUrl(), "instances"); final WebTarget webTarget = client.target(target); // call create broker instances API return webTarget.request(MediaType.APPLICATION_JSON) .post(Entity.form(form), CloudKarafkaCreateInstanceResponse.class); }
@Override public Representation readFrom(Class<Representation> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException { try (InputStreamReader reader = new InputStreamReader(entityStream, CommonParams.CHARSET)) { Gson gson = new GsonBuilder().setDateFormat( CommonParams.FORMAT_DATE).create(); return gson.fromJson(reader, genericType); } catch (JsonSyntaxException e) { throw WebException.badRequest() .message(CommonParams.ERROR_JSON_FORMAT) .moreInfo(e.getMessage()).build(); } }
@Test public void mapResponse_withHeaders() { MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>(); headers.add("h", "v"); new Expectations() { { jaxrsResponse.getStatusInfo(); result = Status.OK; jaxrsResponse.getEntity(); result = "result"; jaxrsResponse.getHeaders(); result = headers; } }; Response response = mapper.mapResponse(null, jaxrsResponse); Assert.assertEquals(Status.OK, response.getStatus()); Assert.assertEquals("result", response.getResult()); Assert.assertEquals(1, response.getHeaders().getHeaderMap().size()); Assert.assertThat(response.getHeaders().getHeader("h"), Matchers.contains("v")); }
@Test public void testPut() throws Exception { MockRepresentation content = new MockRepresentation(); content.setId(1L); content.setETag(1L); MockRequestParameters params = new MockRequestParameters(); params.setId(1L); UriInfo uriInfo = mock(UriInfo.class); MultivaluedMap<String, String> map = new MultivaluedHashMap<>(); map.putSingle(CommonParams.PARAM_VERSION, "v" + Integer.valueOf(CommonParams.VERSION_1).toString()); Mockito.when(uriInfo.getPathParameters()).thenReturn(map); Response response = put(uriInfo, backendPut, content, params); assertEquals(Status.NO_CONTENT.getStatusCode(), response.getStatus()); }
private ContainerRequestContext mockCtx() throws URISyntaxException { ContainerRequestContext ctx = mock(ContainerRequestContext.class); UriInfo uriInfo = mock(UriInfo.class); when(uriInfo.getPath()).thenReturn("/endpoint"); URI requestUri = new URI("/endpoint"); when(uriInfo.getRequestUri()).thenReturn(requestUri); when(ctx.getUriInfo()).thenReturn(uriInfo); when(ctx.getEntityStream()).thenReturn(mock(InputStream.class)); MultivaluedMap<String, String> pathParameters = new MultivaluedHashMap<>(); pathParameters.put(ID, ImmutableList.of(BPG)); pathParameters.put("random-header-parameter", ImmutableList.of(EPSG)); when(uriInfo.getPathParameters()).thenReturn(pathParameters); when(uriInfo.getQueryParameters()).thenReturn(new MultivaluedHashMap<>()); MultivaluedMap<String, String> headers = new MultivaluedHashMap<>(); headers.put("random-header-parameter", ImmutableList.of(EPSG)); headers.put(HttpHeaders.CONTENT_TYPE, ImmutableList.of(ContentType.APPLICATION_JSON.toString())); when(ctx.getHeaders()).thenReturn(headers); return ctx; }
@Override public void writeTo( Object object, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { try (OutputStreamWriter writer = new OutputStreamWriter(entityStream, UTF_8)) { Type jsonType; if (type.equals(genericType)) { jsonType = type; } else { jsonType = genericType; } Globals.newGson().toJson(object, jsonType, writer); } }
@Test public void map_ReturnsOptionalParameter_WithValidData() { // Arrange MultivaluedMap<String, String> queryParameters = new MultivaluedHashMap<>(); // Note there are multiple values for this parameter, to test that the first value is used only queryParameters.put(optionalParameter.getName(), ImmutableList.of("value", "valueB")); when(uriInfoMock.getQueryParameters()).thenReturn(queryParameters); // Act Map<String, String> result = representationRequestParameterMapper.map(product, contextMock); // Assert assertThat(result.size(), is(1)); assertThat(result, hasEntry(optionalParameter.getName(), "value")); }
@Override public void writeTo(CharmAttachmentPost attachment, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { try { JAXBContext context = JAXBContext.newInstance(CharmAttachmentPost.class); Marshaller taskMarshaller = context.createMarshaller(); taskMarshaller.marshal(attachment, entityStream); } catch (JAXBException e) { throw new ProcessingException("Error serializing Attachment to output stream"); } }
@Override public Object readFrom( final Class<Object> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, String> httpHeaders, final InputStream entityStream) throws IOException { try { return objectMapper.readValue(entityStream, type); } catch (final JsonProcessingException ex) { throw new BadRequestException(ex.getMessage(), ex); } }
@Test public void map_ReturnsRequiredParameter_WithValidData() { // Arrange MultivaluedMap<String, String> queryParameters = new MultivaluedHashMap<>(); // Note there are multiple values for this parameter, to test that the first value is used only queryParameters.put(requiredParameter.getName(), ImmutableList.of("value", "valueB")); when(uriInfoMock.getQueryParameters()).thenReturn(queryParameters); // Act Map<String, String> result = representationRequestParameterMapper.map(product, contextMock); // Assert assertThat(result.size(), is(1)); assertThat(result, hasEntry(requiredParameter.getName(), "value")); }
@Test public void map_ReturnsCorrectParameterName_ForQueryParameter() { // Arrange QueryParameter queryParameter = new QueryParameter(); queryParameter.setName("param1"); queryParameter.setIn("query"); queryParameter.setVendorExtension(OpenApiSpecificationExtensions.PARAMETER, parameter.getIdentifier().stringValue()); Operation operation = new Operation(); operation.addParameter(queryParameter); MultivaluedMap<String, String> queryParameters = new MultivaluedHashMap<>(); queryParameters.put(queryParameter.getName(), ImmutableList.of("value", "valueB")); // Act Map<String, String> result = mapper.map(operation, product, requestParameters); // Assert assertThat(result.size(), is(1)); assertThat(result, hasEntry(parameter.getName(), "value")); }
@Test public void testGet() throws Exception { MockRequestParameters params = new MockRequestParameters(); params.setId(1L); UriInfo uriinfo = mock(UriInfo.class); MultivaluedMap<String, String> map = new MultivaluedHashMap<>(); map.putSingle(CommonParams.PARAM_VERSION, "v" + Integer.valueOf(CommonParams.VERSION_1).toString()); Mockito.when(uriinfo.getPathParameters()).thenReturn(map); Response response = get(uriinfo, backendGet, params, true); assertEquals(Status.OK.getStatusCode(), response.getStatus()); assertNotNull(response.getEntity()); assertThat(response.getEntity(), instanceOf(MockRepresentation.class)); }
@SuppressWarnings("boxing") private MultivaluedMap<String, String> testVersionFilter(String version) throws WebApplicationException, NoSuchMethodException { ResourceInfo resourceInfo = mock(ResourceInfo.class); ContainerRequestContext request = mock(ContainerRequestContext.class); UriInfo uriInfo = mock(UriInfo.class); when(request.getUriInfo()).thenReturn(uriInfo); Method method = SinceClass.class.getMethod("dummy"); MultivaluedMap<String, String> prop = new MultivaluedHashMap<>(); prop.putSingle(CommonParams.PARAM_VERSION, version); when(uriInfo.getPathParameters()).thenReturn(prop); VersionFilter filter = spy(new VersionFilter()); when(filter.getResourceInfo()).thenReturn(resourceInfo); when(resourceInfo.getResourceMethod()).thenReturn(method); filter.filter(request); return prop; }
@Test public void extAuthnHandlerSetsErrorAttributeWhenIdentificationFails() throws Exception { when(mockAuthenticationHandlerService.buildSession(any())) .thenReturn(null); when(mockAuthenticationHandlerService.purgeSession(any())) .thenReturn(mock(MultivaluedMap.class)); ProfileRequestContext profileRequestContext = new ProfileRequestContext(); profileRequestContext.addSubcontext(new AuthenticationContext()); MockHttpServletRequest request = getQueryParamRequest(getValidTupasResponseParams()); MockHttpServletResponse response = new MockHttpServletResponse(); when(ExternalAuthentication.getProfileRequestContext("e1s1", request)).thenReturn(profileRequestContext); extAuthnHandler.doGet(request, response); AuthenticationContext authenticationContext = profileRequestContext.getSubcontext(AuthenticationContext.class); assertNotNull(authenticationContext); TupasContext tupasContext = authenticationContext.getSubcontext(TupasContext.class); assertNull(tupasContext); assertNotNull(response.getRedirectedUrl()); }
@Test public void parseSessionDataFailsIfStampIsExpired() throws Exception { ReflectionTestUtils.setField(parser, "clock", expired); MultivaluedMap<String,String> initParams = getValidInitParams(); initParams.putSingle("sessionId", "1234567890"); when(authenticationHandlerUtils.popFromCache(any())).thenReturn(initParams); Map<String,String> attributeNameMap = mock(Map.class); when(attributeNameMap.get("B02K_CUSTID")).thenReturn("ATTRNAME_CUSTID"); when(attributeNameMap.get("B02K_CUSTNAME")).thenReturn("ATTRNAME_CUSTNAME"); MultivaluedMap<String,String> sessionParams = getValidSessionParamsWithHetu(); sessionParams.putSingle("sessionId", "1234567890"); assertNull(parser.parseSessionData(sessionParams)); }
@Test public void testFieldNamesWithSpaceQuoting() throws Exception { QlikAppMessageBodyGenerator generator = new QlikAppMessageBodyGenerator(); VirtualDataset dataset = new VirtualDataset() .setSqlFieldsList(Arrays.asList(new ViewFieldType("test dimension", "VARCHAR"), new ViewFieldType("test \" measure", "INTEGER"))); DatasetConfig datasetConfig = new DatasetConfig() .setName("UNTITLED") .setType(DatasetType.VIRTUAL_DATASET) .setFullPathList(Arrays.asList("space", "folder.ext", "UNTITLED")) .setVirtualDataset(dataset); MultivaluedMap<String, Object> httpHeaders = new MultivaluedHashMap<>(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); assertTrue(generator.isWriteable(datasetConfig.getClass(), null, null, WebServer.MediaType.TEXT_PLAIN_QLIK_APP_TYPE)); generator.writeTo(datasetConfig, DatasetConfig.class, null, new Annotation[] {}, WebServer.MediaType.TEXT_PLAIN_QLIK_APP_TYPE, httpHeaders, baos); String script = new String(baos.toByteArray(), UTF_8); // make sure everything is escaped correctly assertTrue(script.contains(" DIMENSION \"test dimension\"")); assertTrue(script.contains(" MEASURE \"test \"\" measure\"")); assertTrue(script.contains(" FROM \"space\".\"folder.ext\".\"UNTITLED\"")); }
@Override public CharmErrorMessage readFrom(Class<CharmErrorMessage> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException { try { JAXBContext context = JAXBContext.newInstance(CharmErrorMessage.class); Unmarshaller errorUnmarshaller = context.createUnmarshaller(); return (CharmErrorMessage) errorUnmarshaller.unmarshal(entityStream); } catch (JAXBException e) { throw new ProcessingException("Error deserializing Error Message"); } }
@Test public void map_ReturnsNoParameter_WhenOptionalParameterIsMissing() { // Arrange MultivaluedMap<String, String> queryParameters = new MultivaluedHashMap<>(); when(uriInfoMock.getQueryParameters()).thenReturn(queryParameters); // Act Map<String, String> result = representationRequestParameterMapper.map(product, contextMock); // Assert assertThat(result.size(), is(0)); }
@Override public void writeTo(User t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { t.setPassword(null); JsonbConfig config = new JsonbConfig().withNullValues(false); JsonbBuilder.create(config) .toJson(t, entityStream); }
@Override public PropertyBox readFrom(Class<PropertyBox> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException { try (InputStreamReader isr = new InputStreamReader(entityStream, CHARSET); BufferedReader reader = new BufferedReader(isr)) { // read into String StringBuffer content = new StringBuffer(); String line = null; while ((line = reader.readLine()) != null) { content.append(line); } // check property set PropertySet<?> propertySet = null; if (!com.holonplatform.core.Context.get().resource(PropertySet.CONTEXT_KEY, PropertySet.class) .isPresent()) { PropertySetRef propertySetRef = PropertySetRefIntrospector.getPropertySetRef(annotations).orElse(null); if (propertySetRef != null) { try { propertySet = getPropertySetRefIntrospector().getPropertySet(propertySetRef); } catch (PropertySetIntrospectionException e) { throw new WebApplicationException(e.getMessage(), e, Status.INTERNAL_SERVER_ERROR); } } } if (propertySet != null) { return propertySet.execute(() -> readPropertyBox(content.toString())); } else { return readPropertyBox(content.toString()); } } }
protected void logHttpHeaders(MultivaluedMap<String, String> headers) { StringBuilder msg = new StringBuilder("The HTTP headers are: \n"); for (Map.Entry<String, List<String>> entry : headers.entrySet()) { msg.append(entry.getKey()).append(": "); for (int i = 0; i < entry.getValue().size(); i++) { msg.append(entry.getValue().get(i)); if (i < entry.getValue().size() - 1) { msg.append(", "); } } msg.append("\n"); } logger.info(msg.toString()); }
@Override public void writeTo(ApplicationResponse t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException { ByteArrayOutputStream boss = new ByteArrayOutputStream(); ObjectMapper om = jsonProvider.locateMapper(type, MediaType.APPLICATION_JSON_TYPE); if(om != null) { jsonProvider.writeTo(t, type, genericType, annotations, MediaType.APPLICATION_JSON_TYPE, httpHeaders, boss); boss.flush(); } Writer osWriter = new OutputStreamWriter(entityStream); String code, text, prefix; if(StringUtils.hasText(t.getMsgCode())) { code = "400"; prefix = t.getMsgCode(); } else { code = "200"; prefix = ""; } if(StringUtils.hasText(t.getMessage())) { text = prefix + " " + t.getMessage(); } else { text = "ok"; } osWriter.write("<html><body status='"+code+"' statusText='" + text + "'>"); osWriter.flush(); entityStream.write(boss.toByteArray()); boss.close(); osWriter.write("</body></html>"); osWriter.close(); }
/** * 全てのレスポンスに共通するレスポンスヘッダーを追加する. * Access-Control-Allow-Origin, Access-Control-Allow-Headers<br/> * X-Personium-Version<br/> * @param request * @param response */ private void addResponseHeaders(final ContainerRequest request, final ContainerResponse response) { MultivaluedMap<String, Object> mm = response.getHttpHeaders(); String acrh = request.getHeaderValue(HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS); if (acrh != null) { mm.putSingle(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, acrh); } else { mm.remove(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS); } mm.putSingle(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN, HttpHeaders.Value.ASTERISK); // X-Personium-Version mm.putSingle(HttpHeaders.X_PERSONIUM_VERSION, PersoniumUnitConfig.getCoreVersion()); }
@Test public void getWithoutOriginSet() { requestGoneThrough = false; Response resp = target("/").request().get(); assertTrue(requestGoneThrough); assertEquals(204, resp.getStatus()); MultivaluedMap<String, Object> headers = resp.getHeaders(); assertEquals("orgin, content-type, accept, authorization", headers.get("Access-Control-Allow-Headers").get(0)); assertEquals("true", headers.get("Access-Control-Allow-Credentials").get(0)); assertEquals("GET, POST, PUT, DELETE, OPTIONS", headers.get("Access-Control-Allow-Methods").get(0)); }
private SlackCommandResponse showDevice(final MultivaluedMap<String, String> params) { final String text = params.getFirst("text"); if (StringUtils.isEmpty(text)) { final String command = params.getFirst("command"); return help(command); } else { return showByText(text); } }
@Override public JsonElement readFrom(final Class<JsonElement> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, String> httpHeaders, final InputStream entityStream) throws IOException { try (final Reader r = new InputStreamReader(entityStream, StandardCharsets.UTF_8)) { return gson.fromJson(r, JsonElement.class); } }
@Override public void writeTo(Buffer buffer, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { for(int i=0;i<buffer.length();i++) entityStream.write(buffer.getByte(i)); }
@Override public void writeTo(final DefaultRdfStream stream, final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, Object> httpHeaders, final OutputStream entityStream) { LOGGER.debug("Serializing an RdfStream to mimeType: {}", mediaType); final RdfStreamStreamingOutput streamOutput = new RdfStreamStreamingOutput(stream, mediaType); streamOutput.write(entityStream); }
@Test public void testServletResponse() throws IOException { final MultivaluedMap<String, String> headers = new MultivaluedHashMap<>(); final Cookie[] cookies = new Cookie[0]; final MockHttpServletRequest servletRequest = new MockHttpServletRequest("GET", URI.create("/servlet"), headers, null, cookies); final MockHttpServletResponse servletResponse = new MockHttpServletResponse(); final MinijaxRequestContext context = new MinijaxRequestContext(null, servletRequest, servletResponse); getServer().getDefaultApplication().handle(context, servletResponse); assertEquals(200, servletResponse.getStatus()); assertEquals("text/plain", servletResponse.getContentType()); assertEquals("Hello world!", servletResponse.getOutput().trim()); }
@Override public void writeTo( final Widget widget, final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType, final MultivaluedMap<String, Object> httpHeaders, final OutputStream entityStream) throws IOException, WebApplicationException { entityStream.write(String.format("(widget %s %s)", widget.getId(), widget.getValue()).getBytes(StandardCharsets.UTF_8)); }
@SuppressWarnings("unchecked") public <I, O> O postResource(String resourcePath, Class<O> resClazz, final I input, MultivaluedMap<String, String> params, MultivaluedMap<String, String> headers) throws Exception { Response response = null; try { final Invocation.Builder requestBuilder = getRequestBuilder(resourcePath, params, headers); response = requestBuilder.async().post(Entity.entity(input, this.mediaType),new InvocationLogCallback()) .get(REQUEST_THREAD_TIMEOUT, TimeUnit.MILLISECONDS); Response.Status status = Response.Status.fromStatusCode(response.getStatus()); if (status == Response.Status.OK || status == Response.Status.CREATED) { this.lastRequestHeaders = response.getHeaders(); if (response.hasEntity()) { return response.readEntity(resClazz); } return (O) response; } else if (status == Response.Status.NO_CONTENT) { return null; } else { throw new ClientResponseNotOkException(); } } catch (Exception ex) { RestClientException restClientException = createRestClientException("POST", this.webTarget.getUri() + "/" + resourcePath, input, response, ex); log.debug("Error invoking postResource", restClientException); throw restClientException; } }
private static PSFUriPart updatePSF(PSFUriPart psf, MultivaluedMap<String, String> queryParameters) { return updatePSF(psf, ResourceUtils.popQueryParamValue(ASCENDING_FIELD_QUERY_PARAM, queryParameters), ResourceUtils.popQueryParamValue(DESCENDING_FIELD_QUERY_PARAM, queryParameters), ResourceUtils.popQueryParamValue(PAGE_SIZE_QUERY_PARAM, queryParameters), ResourceUtils.popQueryParamValue(PAGE_NUMBER_QUERY_PARAM, queryParameters), ResourceUtils.popQueryParamValue(UPDATE_ROW_COUNT_QUERY_PARAM, queryParameters), queryParameters); }
@Override public void writeTo(Object t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { final Writer w = new OutputStreamWriter(entityStream, API_JSON_SERIALIZE_VALUE_CHARSET); final JsonWriter jsw = new JsonWriter(w); getShortcutSerializer().toJson(t, type, jsw); jsw.close(); }
/** * Get all response headers. * * @return the response headers */ @PublicAtsApi public RestHeader[] getHeaders() { List<RestHeader> headers = new ArrayList<RestHeader>(); MultivaluedMap<String, Object> respHeaders = response.getHeaders(); for (Entry<String, List<Object>> respHeaderEntry : respHeaders.entrySet()) { headers.add(RestHeader.constructRESTHeader(respHeaderEntry.getKey(), respHeaderEntry.getValue())); } return headers.toArray(new RestHeader[headers.size()]); }
@Override public void writeTo(ArrayList arrayList, Class<?> aClass, Type type, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> multivaluedMap, OutputStream outputStream) throws IOException, WebApplicationException { try { XMLOutputFactory outputFactory = XMLOutputFactory.newInstance(); XMLStreamWriter xmlWriter = outputFactory.createXMLStreamWriter(outputStream); writeValue(arrayList, xmlWriter); xmlWriter.flush(); xmlWriter.close(); } catch (XMLStreamException e) { throw new IOException(e); } }
@Override public void writeTo(PropertyBox t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { try (final Writer writer = new OutputStreamWriter(entityStream, CHARSET)) { try { getObjectWriter().writeValue(writer, t); } catch (JsonProcessingException e) { throw new WebApplicationException(e.getMessage(), e, Status.BAD_REQUEST); } } }
@Override public void writeTo(ObjectNode node, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException { mapper.writer().writeValue(entityStream, node); entityStream.flush(); }
public Mapping find(String path, @NotNull MultivaluedMap<String,String> pathParametersFound) { pathParametersFound.clear(); // if the path contains a trailing slash ignore it... String usePath = (path.endsWith("/") ? path.substring(0,path.length() - 1) : path); Mapping result = fixedPathMappings.get((usePath.startsWith("/") ? "" : "/") + usePath); if (result != null) { return result; } // split the path into segments... return find(Arrays.asList((path.startsWith("/") ? path.substring(1) : path).split("/", -1)), 0, pathParametersFound); }
private String requestAccessToken(final String username) throws UnsupportedEncodingException { WebTarget oauth2Service = ClientBuilder.newClient().register(JacksonJaxbJsonProvider.class).target("http://localhost:7001/security"); MultivaluedMap<String, String> request = new MultivaluedHashMap<>(); request.putSingle("grant_type", "client_credentials"); String credentials = Base64.getEncoder().encodeToString((username + ":passw0rd").getBytes("UTF-8")); Map<String, String> oauthResponse = oauth2Service.path("oauth2/token") .request(MediaType.APPLICATION_FORM_URLENCODED_TYPE) .header("Authorization", "Basic " + credentials) .header("X-Log-Token", DiagnosticContext.getLogToken()) .header("X-Service-Generation", "1") .header("X-Client-Version", "1.0.0") .post(Entity.form(request), Map.class); return oauthResponse.get("access_token"); }
@Test public void testContentLength() { final MultivaluedMap<String, String> headers = new MultivaluedHashMap<>(); headers.add("Content-Length", "1024"); final MockHttpServletRequest request = new MockHttpServletRequest("GET", URI.create("/"), headers, null, null); final MinijaxHttpHeaders httpHeaders = new MinijaxHttpHeaders(request); assertEquals(1024, httpHeaders.getLength()); }