Java 类javax.ws.rs.core.MultivaluedMap 实例源码

/**
 * 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());
}