private URI calculateNewRequestURI(URI newBaseURI, URI requestURI, boolean proxy) {
    String baseURIPath = newBaseURI.getRawPath();
    String reqURIPath = requestURI.getRawPath();

    UriBuilder builder = new UriBuilderImpl().uri(newBaseURI);
    String basePath = reqURIPath.startsWith(baseURIPath) ? baseURIPath : getBaseURI().getRawPath();
    String relativePath = reqURIPath.equals(basePath) ? ""
            : reqURIPath.startsWith(basePath) ? reqURIPath.substring(basePath.length()) : reqURIPath;
    builder.path(relativePath);

    String newQuery = newBaseURI.getRawQuery();
    if (newQuery == null) {
        builder.replaceQuery(requestURI.getRawQuery());
    } else {
        builder.replaceQuery(newQuery);
    }

    URI newRequestURI = builder.build();

    resetBaseAddress(newBaseURI);
    URI current = proxy ? newBaseURI : newRequestURI;
    resetCurrentBuilder(current);

    return newRequestURI;
}
 

@Test
public void testAdd() throws IllegalArgumentException, URISyntaxException {
    UriBuilder uriBuilder = new UriBuilderImpl(new URI(RESOURCE_PATH));
    when(uriInfo.getRequestUriBuilder()).thenReturn(uriBuilder);
    
    Response resp = taskRes.addTask(task1);
    
    verify(taskService).addOrUpdate(task1);
    assertThat(resp.getStatus(), equalTo(201));
    URI expectedRedirect = new URI(RESOURCE_PATH + "/1");
    assertThat(resp.getHeaders().get("Location"), contains(expectedRedirect));
}
 

public LocalClientState(URI baseURI, URI currentURI, Map<String, Object> properties) {
    this.baseURI = baseURI;
    
    if (properties != null) {
        this.properties = new HashMap<>(properties);
    }
    
    this.currentBuilder = new UriBuilderImpl(properties).uri(currentURI);
}
 

private void resetCurrentUri(Map<String, Object> props) {
    if (isSupportedScheme(baseURI)) {
        this.currentBuilder = new UriBuilderImpl(props).uri(baseURI);
    } else {
        this.currentBuilder = new UriBuilderImpl(props).uri("/");
    }
}
 

static URI convertStringToURI(String baseAddress) {
    try {
        return URI.create(baseAddress);
    } catch (RuntimeException ex) {
        // no need to check "https" scheme or indeed ':'
        // as the relative address will not work as the base address
        if (baseAddress.startsWith(HTTP_SCHEME)) {
            return new UriBuilderImpl().uriAsTemplate(baseAddress).build();
        }
        throw ex;
    }
}
 

@BeforeEach
public void setup() {
    if (SERVER == null) {
        AnyObjectDAO anyObjectDAO = mock(AnyObjectDAO.class);

        AnyObjectLogic logic = mock(AnyObjectLogic.class);
        when(logic.search(any(SearchCond.class), anyInt(), anyInt(), anyList(), anyString(), anyBoolean())).
                thenAnswer(ic -> {
                    AnyObjectTO printer1 = new AnyObjectTO();
                    printer1.setKey(UUID.randomUUID().toString());
                    printer1.setName("printer1");
                    printer1.setType("PRINTER");
                    printer1.getPlainAttrs().add(new Attr.Builder("location").value("here").build());

                    AnyObjectTO printer2 = new AnyObjectTO();
                    printer2.setKey(UUID.randomUUID().toString());
                    printer2.setName("printer2");
                    printer2.setType("PRINTER");
                    printer2.getPlainAttrs().add(new Attr.Builder("location").value("there").build());

                    return Pair.of(2, Arrays.asList(printer1, printer2));
                });
        when(logic.create(any(AnyObjectCR.class), anyBoolean())).thenAnswer(ic -> {
            AnyObjectTO anyObjectTO = new AnyObjectTO();
            EntityTOUtils.toAnyTO(ic.getArgument(0), anyObjectTO);
            anyObjectTO.setKey(UUID.randomUUID().toString());

            ProvisioningResult<AnyObjectTO> result = new ProvisioningResult<>();
            result.setEntity(anyObjectTO);
            return result;
        });

        SearchCondVisitor searchCondVisitor = mock(SearchCondVisitor.class);
        when(searchCondVisitor.getQuery()).thenReturn(new SearchCond());

        @SuppressWarnings("unchecked")
        SearchCondition<SearchBean> sc = mock(SearchCondition.class);
        doNothing().when(sc).accept(any());
        SearchContext searchContext = mock(SearchContext.class);
        when(searchContext.getCondition(anyString(), eq(SearchBean.class))).thenReturn(sc);

        UriInfo uriInfo = mock(UriInfo.class);
        when(uriInfo.getAbsolutePathBuilder()).thenReturn(new UriBuilderImpl());
        when(uriInfo.getQueryParameters()).thenReturn(new MetadataMap<>());

        MessageContext messageContext = mock(MessageContext.class);
        MockHttpServletRequest httpRequest = new MockHttpServletRequest();
        httpRequest.addHeader(RESTHeaders.NULL_PRIORITY_ASYNC, "false");
        when(messageContext.getHttpServletRequest()).thenReturn(httpRequest);
        when(messageContext.getHttpServletResponse()).thenReturn(new MockHttpServletResponse());

        Request request = mock(Request.class);
        when(request.evaluatePreconditions(any(Date.class))).thenReturn(Response.notModified());
        when(messageContext.getRequest()).thenReturn(request);

        AnyObjectServiceImpl service = new AnyObjectServiceImpl();
        ReflectionTestUtils.setField(service, "anyObjectDAO", anyObjectDAO);
        ReflectionTestUtils.setField(service, "logic", logic);
        ReflectionTestUtils.setField(service, "searchCondVisitor", searchCondVisitor);
        ReflectionTestUtils.setField(service, "searchContext", searchContext);
        ReflectionTestUtils.setField(service, "uriInfo", uriInfo);
        ReflectionTestUtils.setField(service, "messageContext", messageContext);

        JAXRSServerFactoryBean sf = new JAXRSServerFactoryBean();
        sf.setAddress(LOCAL_ADDRESS);
        sf.setResourceClasses(AnyObjectService.class);
        sf.setResourceProvider(
                AnyObjectService.class,
                new SingletonResourceProvider(service, true));

        sf.setInInterceptors(Arrays.asList(gzipInInterceptor, validationInInterceptor));
        sf.setOutInterceptors(Arrays.asList(gzipOutInterceptor));

        sf.setProviders(Arrays.asList(dateParamConverterProvider, jsonProvider, xmlProvider, yamlProvider,
                exceptionMapper, searchContextProvider, addETagFilter));

        SERVER = sf.create();
    }

    assertNotNull(SERVER);
}
 

public void reset() {
    requestHeaders.clear();
    response = null;
    currentBuilder = new UriBuilderImpl(properties).uri(baseURI);
    templates = null;
}
 

protected void resetCurrentBuilder(URI uri) {
    state.setCurrentBuilder(new UriBuilderImpl(uri));
}