org.springframework.http.ResponseEntity.getStatusCode()

public static boolean is2xxSuccessful(ResponseEnreplacedy responseEnreplacedy) {
    if (Objects.isNull(responseEnreplacedy) || Objects.isNull(responseEnreplacedy.getStatusCode())) {
        return false;
    }
    return responseEnreplacedy.getStatusCode().is2xxSuccessful();
}

public static boolean isOk(ResponseEnreplacedy responseEnreplacedy) {
    if (Objects.isNull(responseEnreplacedy) || Objects.isNull(responseEnreplacedy.getStatusCode())) {
        return false;
    }
    return HttpStatus.OK.equals(responseEnreplacedy.getStatusCode());
}

private void replacedertOkResponse(String path, String body) {
    ResponseEnreplacedy<String> enreplacedy = this.restTemplate.getForEnreplacedy(path, String.clreplaced);
    replacedertThat(enreplacedy.getStatusCode()).isEqualTo(HttpStatus.OK);
    replacedertThat(enreplacedy.getBody()).isEqualTo(body);
}

public <T> T httpExchange(String url, HttpMethod method, HttpEnreplacedy httpEnreplacedy, Clreplaced<T> responseType) throws RestClientException {
    if (StringUtils.isBlank(url)) {
        throw new RestClientException("request url can not blank");
    }
    if (url.indexOf(' ') >= 0) {
        log.warn("url中含有空格，现将空格转换为20%，以便能正常执行请求");
        url = url.replaceAll(" ", "20%");
    }
    try {
        ResponseEnreplacedy<T> responseEnreplacedy = restTemplate.exchange(url, method, httpEnreplacedy, responseType);
        HttpStatus status = responseEnreplacedy.getStatusCode();
        T res = responseEnreplacedy.getBody();
        if (status == HttpStatus.OK) {
            return res;
        }
    } catch (RestClientException e) {
        log.error("request RestClientException：" + e.getLocalizedMessage());
        throw e;
    }
    return null;
}

@Test
@DisplayName("SCOPE 测试")
void testScopeWhenPreplaceded() {
    OAuth2RestTemplate template = oauth2RestTemplate("admin", "123456", Arrays.asList("READ", "WRITE"));
    ResponseEnreplacedy<String> writeResponse = template.exchange(URL + "/write", GET, null, String.clreplaced);
    replacedertEquals(HttpStatus.OK, writeResponse.getStatusCode());
    replacedertEquals("WRITE", writeResponse.getBody());
    ResponseEnreplacedy<String> readResponse = template.exchange(URL + "/read", GET, null, String.clreplaced);
    replacedertEquals(HttpStatus.OK, readResponse.getStatusCode());
    replacedertEquals("READ", readResponse.getBody());
}

public void findLatestVersion() {
    if (!this.canCheckForNewVersion()) {
        return;
    }
    ResponseEnreplacedy<String> response = this.restClient.fetch(LATEST_RELEASE_URL, this.state.getEtag());
    if (response.getStatusCode().is2xxSuccessful()) {
        GithubRelease latestRelease = this.restClient.deserialize(response, GithubRelease.clreplaced, GithubRelease::new);
        this.state.setLatestVersion(latestRelease.getName());
        Githubreplacedet[] replacedets = latestRelease.getreplacedets();
        if (replacedets != null && replacedets.length == 1) {
            this.state.setreplacedet(replacedets[0]);
        } else {
            this.state.setreplacedet(null);
        }
        this.state.setReleaseUrl(latestRelease.getUrl());
    }
    this.state.setEtag(response.getHeaders().getETag());
    this.state.setChecked(new Date());
}

private void fetchTldVersions() {
    try {
        ResponseEnreplacedy<String> response = this.restClient.fetch(TLD_VERSIONS_URL, this.state.getEtag());
        if (response.getStatusCode().is2xxSuccessful()) {
            this.state.setCompatibilityVersions(this.restClient.deserialize(response, CompatibilityVersions.clreplaced, null));
            this.state.setEtag(response.getHeaders().getETag());
            this.currentCompatibilityVersion = this.state.getCompatibilityVersions().floor(this.parsedCurrentVersion);
        }
        this.state.setChecked(new Date());
        this.writeState();
    } catch (AbortException e) {
    // ignore
    }
}

HttpStatus getResponseStatusCode() {
    return responseEnreplacedy.getStatusCode();
}

/**
 * Delete a alarm.
 *
 * @param alarmId ID to alarm to delete
 */
public boolean deleteAlarm(final String alarmId) {
    final ResponseEnreplacedy<String> response = restTemplate.exchange(seyrenUrl + API_ALARMS + "/" + alarmId, HttpMethod.DELETE, null, String.clreplaced);
    LOGGER.info("Delete alarm {}. Response {}", alarmId, response.getStatusCode());
    return response.getStatusCode().is2xxSuccessful();
}

/**
 * SUBSCRIPTION PART *
 */
/**
 * Add a new subscription to a alarm.
 *
 * @param subscription the subscription to add
 * @param alarmId the ID of the alarm to add subscription
 * @throws SeyrenException If response is not like 2xx (if alarm as the same name)
 */
public void addSubscription(final Subscription subscription, final String alarmId) {
    final ResponseEnreplacedy<Object> response = restTemplate.postForEnreplacedy(seyrenUrl + API_ALARMS + "/" + alarmId + "/subscriptions/", subscription, Object.clreplaced);
    if (!response.getStatusCode().is2xxSuccessful()) {
        throw new SeyrenException("addSubscription", response.getStatusCode().value());
    }
    LOGGER.info("Add subscription for alarm {}. Response {}", alarmId, response.getStatusCode());
}

public boolean deleteSubscription(final String alarmId, final String subscriptionId) {
    final ResponseEnreplacedy<String> response = restTemplate.exchange(seyrenUrl + API_ALARMS + "/" + alarmId + "/subscriptions/" + subscriptionId, HttpMethod.DELETE, null, String.clreplaced);
    LOGGER.info("Delete subscription {} for alarm {}. Response {}", subscriptionId, alarmId, response.getStatusCode());
    return response.getStatusCode().is2xxSuccessful();
}

/**
 * Authenticates towards the admin REST interface as Keycloak Admin using username/preplacedword.
 * @return HttpHeaders including the Authorization header / acces token
 * @throws JSONException in case of errors
 */
private static HttpHeaders authenticateKeycloakAdmin() throws JSONException {
    // Authenticate Admin
    HttpHeaders headers = new HttpHeaders();
    headers.add(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_FORM_URLENCODED.toString());
    HttpEnreplacedy<String> request = new HttpEnreplacedy<>("client_id=admin-cli" + "&username=" + KEYCLOAK_ADMIN_USER + "&preplacedword=" + KEYCLOAK_ADMIN_PWD + "&grant_type=preplacedword", headers);
    ResponseEnreplacedy<String> response = restTemplate.postForEnreplacedy(KEYCLOAK_URL + "/realms/master/protocol/openid-connect/token", request, String.clreplaced);
    replacedertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
    JSONObject json = new JSONObject(response.getBody());
    String accessToken = json.getString("access_token");
    String tokenType = json.getString("token_type");
    // Create REST request header
    headers = new HttpHeaders();
    headers.add(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_JSON.toString());
    headers.add(HttpHeaders.AUTHORIZATION, tokenType + " " + accessToken);
    return headers;
}

private ResponseEnreplacedy<Object> testException(Exception ex) {
    try {
        ResponseEnreplacedy<Object> responseEnreplacedy = this.exceptionHandlerSupport.handleException(ex, this.request);
        // SPR-9653
        if (HttpStatus.INTERNAL_SERVER_ERROR.equals(responseEnreplacedy.getStatusCode())) {
            replacedertSame(ex, this.servletRequest.getAttribute("javax.servlet.error.exception"));
        }
        this.defaultExceptionResolver.resolveException(this.servletRequest, this.servletResponse, null, ex);
        replacedertEquals(this.servletResponse.getStatus(), responseEnreplacedy.getStatusCode().value());
        return responseEnreplacedy;
    } catch (Exception ex2) {
        throw new IllegalStateException("handleException threw exception", ex2);
    }
}

@Test
public void getNotModified() {
    String s = template.getForObject(baseUrl + "/status/notmodified", String.clreplaced);
    replacedertNull("Invalid content", s);
    ResponseEnreplacedy<String> enreplacedy = template.getForEnreplacedy(baseUrl + "/status/notmodified", String.clreplaced);
    replacedertEquals("Invalid response code", HttpStatus.NOT_MODIFIED, enreplacedy.getStatusCode());
    replacedertNull("Invalid content", enreplacedy.getBody());
}

@Test
public void getEnreplacedy() {
    ResponseEnreplacedy<String> enreplacedy = template.getForEnreplacedy(baseUrl + "/{method}", String.clreplaced, "get");
    replacedertEquals("Invalid content", helloWorld, enreplacedy.getBody());
    replacedertFalse("No headers", enreplacedy.getHeaders().isEmpty());
    replacedertEquals("Invalid content-type", textContentType, enreplacedy.getHeaders().getContentType());
    replacedertEquals("Invalid status code", HttpStatus.OK, enreplacedy.getStatusCode());
}

@Test
public void getNotModified() throws Exception {
    Future<ResponseEnreplacedy<String>> responseFuture = template.getForEnreplacedy(baseUrl + "/status/notmodified", String.clreplaced);
    ResponseEnreplacedy<String> enreplacedy = responseFuture.get();
    replacedertEquals("Invalid response code", HttpStatus.NOT_MODIFIED, enreplacedy.getStatusCode());
    replacedertNull("Invalid content", enreplacedy.getBody());
}

@Test
public void getEnreplacedy() throws Exception {
    Future<ResponseEnreplacedy<String>> future = template.getForEnreplacedy(baseUrl + "/{method}", String.clreplaced, "get");
    ResponseEnreplacedy<String> enreplacedy = future.get();
    replacedertEquals("Invalid content", helloWorld, enreplacedy.getBody());
    replacedertFalse("No headers", enreplacedy.getHeaders().isEmpty());
    replacedertEquals("Invalid content-type", textContentType, enreplacedy.getHeaders().getContentType());
    replacedertEquals("Invalid status code", HttpStatus.OK, enreplacedy.getStatusCode());
}

// SPR-15560
@Test
public void emptyPathSegments() throws Exception {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setErrorHandler(NO_OP_ERROR_HANDLER);
    URI url = new URI("http://localhost:" + port + "//");
    ResponseEnreplacedy<String> response = restTemplate.getForEnreplacedy(url, String.clreplaced);
    replacedertEquals(HttpStatus.OK, response.getStatusCode());
}

@Test
public void should_ReceiveBadRequest_When_IncorrectNumberOfParametersProvided() {
    Map<String, Integer> requestObject = new HashMap<>();
    requestObject.put("number", 3);
    requestObject.put("bad_number", 33);
    String methodName = "addOne";
    ResponseEnreplacedy<String> response = sendVaadinServiceRequest(methodName, requestObject, String.clreplaced);
    replacedertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
    replacedertVaadinErrorResponse(response.getBody(), methodName);
}

@Test
public void should_RequestFail_When_MethodCallProhibitedByClreplacedAnnotation() {
    String methodName = "deniedByClreplaced";
    ResponseEnreplacedy<String> response = sendVaadinServiceRequest(methodName, Collections.emptyMap(), String.clreplaced);
    replacedertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
    replacedertVaadinErrorResponse(response.getBody(), methodName);
}

@Test
public void should_ReceiveInternalError_When_ServiceMethodThrowsException() {
    String methodName = "throwsException";
    ResponseEnreplacedy<String> response = sendVaadinServiceRequest(methodName, Collections.emptyMap(), String.clreplaced);
    replacedertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
    replacedertVaadinErrorResponse(response.getBody(), methodName);
}

@Test
public void should_RequestFail_When_InvalidRoleUsedInRequest() {
    String methodName = "permitRoleAdmin";
    ResponseEnreplacedy<String> response = sendVaadinServiceRequest(methodName, Collections.emptyMap(), String.clreplaced);
    replacedertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
    replacedertVaadinErrorResponse(response.getBody(), methodName);
}

private String getAccessToken() {
    List<ClientHttpRequestInterceptor> interceptors = template.getRestTemplate().getInterceptors();
    ClientHttpRequestInterceptor getAccessTokenInterceptor = (request, body, execution) -> {
        HttpHeaders headers = request.getHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
        return execution.execute(request, body);
    };
    interceptors.add(getAccessTokenInterceptor);
    @SuppressWarnings("rawtypes")
    ResponseEnreplacedy<Map> response = template.postForEnreplacedy(String.format("http://localhost:%d/oauth/token", port), getTokenRequest(), Map.clreplaced);
    interceptors.remove(getAccessTokenInterceptor);
    replacedertEquals(HttpStatus.OK, response.getStatusCode());
    return Optional.ofNullable(response.getBody()).map(body -> body.get("access_token")).map(Object::toString).orElseThrow(() -> new replacedertionError("Did not get an access token from access token request"));
}

@Test
public void should_AllowAnonymousAccess_When_AnonymousAllowed() {
    template.getRestTemplate().getInterceptors().clear();
    tokenInjected = false;
    ResponseEnreplacedy<String> response = sendVaadinServiceRequest("hasAnonymousAccess", Collections.emptyMap(), String.clreplaced);
    replacedertEquals(HttpStatus.OK, response.getStatusCode());
    replacedertEquals("\"anonymous success\"", response.getBody());
}

@Test
public void should_ReceiveCorrectResponse_When_ComplexObjectIsReturnedByServiceMethod() {
    String name = "test";
    Map<String, Object> complexRequestPart = new HashMap<>();
    complexRequestPart.put("name", name);
    complexRequestPart.put("count", 3);
    ResponseEnreplacedy<DemoVaadinService.ComplexResponse> response = sendVaadinServiceRequest("complexEnreplacediesTest", Collections.singletonMap("request", complexRequestPart), DemoVaadinService.ComplexResponse.clreplaced);
    replacedertEquals(HttpStatus.OK, response.getStatusCode());
    Map<Integer, List<String>> expectedResult = new HashMap<>();
    expectedResult.put(0, Collections.emptyList());
    expectedResult.put(1, Collections.singletonList("0"));
    expectedResult.put(2, Arrays.asList("0", "1"));
    replacedertEquals(new DemoVaadinService.ComplexResponse(name, expectedResult), response.getBody());
}

@Test
public void should_ReceiveBadRequest_When_NoParametersProvided() {
    String methodName = "addOne";
    ResponseEnreplacedy<String> response = sendVaadinServiceRequest(methodName, Collections.emptyMap(), String.clreplaced);
    replacedertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
    replacedertVaadinErrorResponse(response.getBody(), methodName);
}

@Test
public void should_ReceiveSameResponses_When_DifferentNameCaseUsed() {
    String serviceName1 = TEST_SERVICE_NAME.toUpperCase(Locale.ENGLISH);
    String serviceName2 = TEST_SERVICE_NAME.toLowerCase(Locale.ENGLISH);
    replacedertNotEquals(serviceName1, serviceName2);
    replacedertTrue(serviceName1.equalsIgnoreCase(serviceName2));
    String methodName = "noReturnNoArguments";
    String serviceMethod1 = methodName.toUpperCase(Locale.ENGLISH);
    String serviceMethod2 = methodName.toLowerCase(Locale.ENGLISH);
    replacedertNotEquals(serviceMethod1, serviceMethod2);
    replacedertTrue(serviceMethod1.equalsIgnoreCase(serviceMethod2));
    ResponseEnreplacedy<String> response1 = template.postForEnreplacedy(getRequestUrl(serviceName1, serviceMethod1), Collections.emptyMap(), String.clreplaced);
    ResponseEnreplacedy<String> response2 = template.postForEnreplacedy(getRequestUrl(serviceName2, serviceMethod2), Collections.emptyMap(), String.clreplaced);
    replacedertEquals(HttpStatus.OK, response1.getStatusCode());
    replacedertEquals("null", response1.getBody());
    replacedertEquals("Expected to have identical responses for requests that differ in method name case and service name case only", response1, response2);
}

@Test
public void should_ReceiveCorrectResponse_When_MethodWithNoReturnCalled() {
    ResponseEnreplacedy<String> response = sendVaadinServiceRequest("noReturnNoArguments", Collections.emptyMap(), String.clreplaced);
    replacedertEquals(HttpStatus.OK, response.getStatusCode());
    replacedertEquals("null", response.getBody());
}

@Test
public void should_ReceiveCorrectResponse_When_CorrectRequestIsProvided() {
    int argument = 3;
    String methodName = "addOne";
    ResponseEnreplacedy<Integer> response = sendVaadinServiceRequest(methodName, Collections.singletonMap("number", argument), Integer.clreplaced);
    replacedertEquals(HttpStatus.OK, response.getStatusCode());
    replacedertEquals(String.format("Method '%s' was expected to increment its argument by 1 and return it, but that did not happen", methodName), Integer.valueOf(argument + 1), response.getBody());
}

@Test
public void should_ReceiveBadRequest_When_IncorrectParameterTypesProvided() {
    String methodName = "addOne";
    ResponseEnreplacedy<String> response = sendVaadinServiceRequest(methodName, Collections.singletonMap("number", Arrays.asList("this", "is", "wrong")), String.clreplaced);
    replacedertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
    replacedertVaadinErrorResponse(response.getBody(), methodName);
}

private ResponseEnreplacedy getFuturesResults(List<Future<ResponseEnreplacedy>> futures) {
    int unauthorized = 0;
    int errors = 0;
    int timeouts = 0;
    final int listSize = futures.size();
    ResponseEnreplacedy responseEnreplacedy = null;
    try {
        int size = listSize;
        while (size > 0) {
            for (int i = 0; i < size; i++) {
                if (futures.get(i).isDone()) {
                    responseEnreplacedy = futures.get(i).get();
                    switch(responseEnreplacedy.getStatusCode()) {
                        case OK:
                            return responseEnreplacedy;
                        case UNAUTHORIZED:
                            unauthorized++;
                            futures.remove(i);
                            break;
                        case REQUEST_TIMEOUT:
                            timeouts++;
                            futures.remove(i);
                            break;
                        case INTERNAL_SERVER_ERROR:
                            errors++;
                            futures.remove(i);
                            break;
                        default:
                            futures.remove(i);
                            break;
                    }
                    break;
                }
            }
            size = futures.size();
        }
        if (errors == listSize || unauthorized == listSize || timeouts == listSize) {
            return responseEnreplacedy;
        }
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
    return new ResponseEnreplacedy(HttpStatus.INTERNAL_SERVER_ERROR);
}

@Test
public void test_getIdenreplacedyGroupDetails_success() throws Exception {
    String group = "group1";
    String token = "test4ig8L3EpsJZSLAMg";
    List<String> policies = new ArrayList<>();
    policies.add("r_users_safe1");
    policies.add("r_users_safe2");
    OIDCGroup oidcGroup = new OIDCGroup("123-123-123", policies);
    when(OIDCUtil.getIdenreplacedyGroupDetails(group, token)).thenReturn(oidcGroup);
    ResponseEnreplacedy<String> expectedResponseEnreplacedy = ResponseEnreplacedy.status(HttpStatus.OK).body(JSONUtil.getJSON(oidcGroup));
    ResponseEnreplacedy<String> actualResponse = oidcAuthService.getIdenreplacedyGroupDetails(group, token);
    replacedertEquals(expectedResponseEnreplacedy.getStatusCode(), actualResponse.getStatusCode());
    replacedertEquals(expectedResponseEnreplacedy.getBody(), actualResponse.getBody());
}

@Test
public void test_searchGroupInAzureAD_Success() throws Exception {
    String ssoToken = "abcd";
    String groupName = "testgroup";
    when(OIDCUtil.getSSOToken()).thenReturn(ssoToken);
    DirectoryObjects groups = new DirectoryObjects();
    DirectoryObjectsList groupsList = new DirectoryObjectsList();
    List<DirectoryGroup> allGroups = new ArrayList<>();
    DirectoryGroup directoryGroup1 = new DirectoryGroup();
    directoryGroup1.setDisplayName("testgroup");
    directoryGroup1.setGroupName("testgroup");
    directoryGroup1.setEmail(null);
    allGroups.add(directoryGroup1);
    DirectoryGroup directoryGroup2 = new DirectoryGroup();
    directoryGroup2.setDisplayName("testgroup1");
    directoryGroup2.setGroupName("testgroup1");
    directoryGroup2.setEmail(null);
    allGroups.add(directoryGroup1);
    groupsList.setValues(allGroups.toArray(new DirectoryGroup[allGroups.size()]));
    groups.setData(groupsList);
    when(OIDCUtil.getGroupsFromAAD(ssoToken, groupName)).thenReturn(allGroups);
    ResponseEnreplacedy<DirectoryObjects> responseEnreplacedy = oidcAuthService.searchGroupInAzureAD(groupName);
    replacedertEquals(HttpStatus.OK, responseEnreplacedy.getStatusCode());
    replacedertEquals(2, responseEnreplacedy.getBody().getData().getValues().length);
}

@Test
public void test_getGroupObjectIdFromAzure_404() throws Exception {
    String ssoToken = "abcd";
    String groupName = "group1";
    when(OIDCUtil.getSSOToken()).thenReturn(null);
    ResponseEnreplacedy<String> responseEnreplacedyExpected = ResponseEnreplacedy.status(HttpStatus.BAD_REQUEST).body("{\"errors\":[\"Failed to get SSO token for Azure AD access\"]}");
    ResponseEnreplacedy<String> responseEnreplacedyActual = oidcAuthService.getGroupObjectIdFromAzure(groupName);
    replacedertEquals(HttpStatus.BAD_REQUEST, responseEnreplacedyActual.getStatusCode());
    replacedertEquals(responseEnreplacedyExpected.toString(), responseEnreplacedyActual.toString());
}

@Test
public void testsearchGroupEmailInAzureADSuccess() throws Exception {
    String ssoToken = "abcd";
    String email = "[email protected]";
    when(OIDCUtil.getSSOToken()).thenReturn(ssoToken);
    DirectoryObjects groups = new DirectoryObjects();
    DirectoryObjectsList groupsList = new DirectoryObjectsList();
    List<DirecotryGroupEmail> allGroups = new ArrayList<>();
    DirecotryGroupEmail directoryGroup1 = new DirecotryGroupEmail();
    directoryGroup1.setId(null);
    directoryGroup1.setEmail("[email protected]");
    allGroups.add(directoryGroup1);
    DirecotryGroupEmail directoryGroup2 = new DirecotryGroupEmail();
    directoryGroup2.setId(null);
    directoryGroup2.setEmail("[email protected]");
    allGroups.add(directoryGroup1);
    groupsList.setValues(allGroups.toArray(new DirecotryGroupEmail[allGroups.size()]));
    groups.setData(groupsList);
    when(OIDCUtil.getGroupsEmailFromAAD(ssoToken, email)).thenReturn(allGroups);
    ResponseEnreplacedy<DirectoryObjects> responseEnreplacedy = oidcAuthService.searchGroupEmailInAzureAD(email);
    replacedertEquals(HttpStatus.OK, responseEnreplacedy.getStatusCode());
    replacedertEquals(2, responseEnreplacedy.getBody().getData().getValues().length);
}

@Test
public void test_getGroupObjectIdFromAzure_success() throws Exception {
    String ssoToken = "abcd";
    String groupName = "group1";
    when(OIDCUtil.getSSOToken()).thenReturn(ssoToken);
    when(OIDCUtil.getGroupObjectResponse(ssoToken, groupName)).thenReturn("abcdefg");
    ResponseEnreplacedy<String> responseEnreplacedyExpected = ResponseEnreplacedy.status(HttpStatus.OK).body("{\"data\":{\"objectId\": \"abcdefg\"}}");
    ResponseEnreplacedy<String> responseEnreplacedyActual = oidcAuthService.getGroupObjectIdFromAzure(groupName);
    replacedertEquals(HttpStatus.OK, responseEnreplacedyActual.getStatusCode());
    replacedertEquals(responseEnreplacedyExpected.toString(), responseEnreplacedyActual.toString());
}

@Test
public void test_searchByGroupName_successfully() {
    DirectoryGroup dirGrp = new DirectoryGroup();
    dirGrp.setDisplayName("test_group");
    dirGrp.setEmail("[email protected]");
    dirGrp.setGroupName("test_group");
    List<DirectoryGroup> allGroups = new ArrayList<>();
    allGroups.add(dirGrp);
    DirectoryObjects groups = new DirectoryObjects();
    DirectoryObjectsList groupsList = new DirectoryObjectsList();
    groupsList.setValues(allGroups.toArray(new DirectoryGroup[allGroups.size()]));
    groups.setData(groupsList);
    ResponseEnreplacedy<DirectoryObjects> responseEnreplacedyExpected = ResponseEnreplacedy.status(HttpStatus.OK).body(groups);
    when(ldapTemplate.search(Mockito.anyString(), Mockito.anyString(), Mockito.any(AttributesMapper.clreplaced))).thenReturn(allGroups);
    ResponseEnreplacedy<DirectoryObjects> responseEnreplacedy = directoryService.searchByGroupName("test_group");
    replacedertEquals(HttpStatus.OK, responseEnreplacedy.getStatusCode());
    replacedertEquals(responseEnreplacedyExpected.getBody().getData().getValues()[0], responseEnreplacedy.getBody().getData().getValues()[0]);
}

@Test
public void test_getAccessPolicyInfo_failure_400() {
    String token = "5PDrOhsy4ig8L3EpsJZSLAMg";
    String accessId = "";
    String responseJson = "{\"errors\":[\"Missing accessid \"]}";
    ResponseEnreplacedy<String> responseEnreplacedyExpected = ResponseEnreplacedy.status(HttpStatus.BAD_REQUEST).body(responseJson);
    ResponseEnreplacedy<String> responseEnreplacedy = accessService.getPolicyInfo(token, accessId);
    replacedertEquals(HttpStatus.BAD_REQUEST, responseEnreplacedy.getStatusCode());
    replacedertEquals(responseEnreplacedyExpected, responseEnreplacedy);
}

@Test
public void test_deleteAccessPolicy_failure_400() {
    String token = "5PDrOhsy4ig8L3EpsJZSLAMg";
    String accessId = "";
    String responseJson = "{\"errors\":[\"Missing accessid \"]}";
    ResponseEnreplacedy<String> responseEnreplacedyExpected = ResponseEnreplacedy.status(HttpStatus.BAD_REQUEST).body(responseJson);
    ResponseEnreplacedy<String> responseEnreplacedy = accessService.deletePolicyInfo(token, accessId);
    replacedertEquals(HttpStatus.BAD_REQUEST, responseEnreplacedy.getStatusCode());
}

/**
 * Validate the approval Response
 *
 * @param responseEnreplacedy
 * @param certName
 * @return
 */
private ResponseEnreplacedy<String> validateApprovalResponse(ResponseEnreplacedy responseEnreplacedy, String certName) {
    if (responseEnreplacedy.getStatusCode().equals(HttpStatus.OK)) {
        printLogMessage(SSLCertificateConstants.GET_PENDING_APPROVAL_CERT_PROCESS, String.format(" " + "External Process Completed for Certificate = [%s]  ", certName));
        return ResponseEnreplacedy.status(HttpStatus.OK).body(MESSAGES + "Successfully updated the details" + " for external certificate" + certName + "\"]}");
    } else {
        printLogMessage(SSLCertificateConstants.GET_PENDING_APPROVAL_CERT_PROCESS, String.format(" External Process Process failed  for Certificate [%s]  ", certName));
        return ResponseEnreplacedy.status(HttpStatus.INTERNAL_SERVER_ERROR).body(ERRORS + "Failed to " + "update details for external certificate" + certName + "\"]}");
    }
}

private boolean checkforDuplicateFolder(Map<String, Object> requestParams, String token) {
    if (requestParams.get("path") != null) {
        String path = requestParams.get("path").toString().toLowerCase();
        ResponseEnreplacedy<String> valutResponse = restProcessor.get("/" + path, token);
        if (valutResponse.getStatusCode().equals(HttpStatus.OK)) {
            return true;
        }
        return false;
    }
    return false;
}

private boolean checkforDuplicateAwsGroup(Map<String, Object> requestParams, String token) {
    if (requestParams.get("role") != null) {
        String role = requestParams.get("role").toString();
        ResponseEnreplacedy<String> valutResponse = restProcessor.get("/auth/aws/role/" + role, token);
        if (HttpStatus.OK.equals(valutResponse.getStatusCode())) {
            return true;
        }
        return false;
    }
    return false;
}

@Test
void testApproveMissing() throws Exception {
    ResponseEnreplacedy<LeaveRequestDTO> response = resttemplate.postForEnreplacedy("/approve/{id}", null, LeaveRequestDTO.clreplaced, UUID.randomUUID());
    replacedertThat(response.getStatusCode()).isEqualByComparingTo(NO_CONTENT);
}

@Test
void testApprove() throws Exception {
    LeaveRequest saved = repository.save(new LeaveRequest("Alice", of(2019, 11, 30), of(2019, 12, 3), PENDING));
    ResponseEnreplacedy<LeaveRequestDTO> response = resttemplate.postForEnreplacedy("/approve/{id}", null, LeaveRequestDTO.clreplaced, saved.getId());
    replacedertThat(response.getStatusCode()).isEqualByComparingTo(ACCEPTED);
    replacedertThat(response.getHeaders().getContentType()).isEqualByComparingTo(APPLICATION_JSON);
    replacedertThat(response.getBody().getEmployee()).isEqualTo("Alice");
    replacedertThat(response.getBody().getStatus()).isEqualByComparingTo(APPROVED);
}

@Test
void testDeny() throws Exception {
    LeaveRequest saved = repository.save(new LeaveRequest("Alice", of(2019, 11, 30), of(2019, 12, 3), PENDING));
    ResponseEnreplacedy<LeaveRequestDTO> response = resttemplate.postForEnreplacedy("/deny/{id}", null, LeaveRequestDTO.clreplaced, saved.getId());
    replacedertThat(response.getStatusCode()).isEqualByComparingTo(ACCEPTED);
    replacedertThat(response.getHeaders().getContentType()).isEqualByComparingTo(APPLICATION_JSON);
    replacedertThat(response.getBody().getEmployee()).isEqualTo("Alice");
    replacedertThat(response.getBody().getStatus()).isEqualByComparingTo(DENIED);
}

@Test
void testRequest() throws Exception {
    LocalDate from = of(2019, 11, 30);
    LocalDate to = of(2019, 12, 3);
    ResponseEnreplacedy<LeaveRequestDTO> response = resttemplate.postForEnreplacedy("/request/{employee}?from={from}&to={to}", null, LeaveRequestDTO.clreplaced, "Alice", from, to);
    replacedertThat(response.getStatusCode()).isEqualByComparingTo(ACCEPTED);
    replacedertThat(response.getHeaders().getContentType()).isEqualByComparingTo(APPLICATION_JSON);
    replacedertThat(response.getBody().getEmployee()).isEqualTo("Alice");
    replacedertThat(response.getBody().getFromDate()).isEqualTo(from);
    replacedertThat(response.getBody().getToDate()).isEqualTo(to);
    replacedertThat(response.getBody().getStatus()).isEqualByComparingTo(PENDING);
}

@Test
public void testOpenAPI() throws Exception {
    ResponseEnreplacedy<String> response = web.getForEnreplacedy(url() + "/swagger.json", String.clreplaced);
    replacedertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
}

@Test
public void testStaticContent() throws Exception {
    ResponseEnreplacedy<String> response = web.getForEnreplacedy(baseurl() + "/static/org.teiid.v1.xml", String.clreplaced);
    replacedertThat(response.getStatusCode(), equalTo(HttpStatus.OK));
}

@Test
void should_NotContainAnyLinks_When_ExportIsRequested() {
    ResponseEnreplacedy<WorkbasketDefinitionCollectionRepresentationModel> response = executeExportRequestForDomain("DOMAIN_A");
    replacedertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
    replacedertThat(response.getBody()).isNotNull();
    replacedertThat(response.getBody().getLink(IreplacedinkRelations.SELF)).isPresent();
    replacedertThat(response.getBody().getContent()).extracting(WorkbasketDefinitionRepresentationModel::getWorkbasket).extracting(WorkbasketRepresentationModel::getLinks).extracting(Links::isEmpty).containsOnly(true);
}

@Test
public void integrationsListForbidden() {
    ResponseEnreplacedy<JsonNode> response = restTemplate().getForEnreplacedy("/api/v1/integrations", JsonNode.clreplaced);
    replacedertThat(response.getStatusCode()).as("integrations list status code").isEqualTo(HttpStatus.FORBIDDEN);
}