how to use this class :
package com.salesforce.dataconnectors.test.endpoint.api;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;

import com.salesforce.atf.testclient.extensions.app.DynamicKeyStoreFactoryExtension;
import com.salesforce.atf.testclient.extensions.context.TestRunContextExtension;
import com.salesforce.cdp.api.dataconnectors.ApiException;
import com.salesforce.cdp.model.dataconnectors.ExtractDataRequestBody;
import com.salesforce.cdp.model.dataconnectors.TestConnectionRequestBody;
import com.salesforce.dataconnectors.test.DataConnectorsFitTestManager;
import com.salesforce.dataconnectors.test.TestConstants;
import com.salesforce.dataconnectors.test.endpoint.DataConnectorsEndpointFitTestManager;
import com.salesforce.dataconnectors.test.tags.Functional;
import com.salesforce.dataconnectors.test.tags.Smoke;
import com.salesforce.fit.ServiceValidation;
import java.util.Arrays;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.context.annotation.ComponentScan;

@Slf4j
@ComponentScan("com.salesforce.cdp")
@ServiceValidation(DataConnectorsFitTestManager.DATA_CONNECTORS_APP)
@ExtendWith({TestRunContextExtension.class, DynamicKeyStoreFactoryExtension.class})
@Functional
public class DataConnectorsHttpTest extends DataConnectorsEndpointFitTestManager {
 private TestConnectionRequestBody requestBody;
 private ExtractDataRequestBody extractDataRequestBody;
 protected final String httpUrlConnectorKey = "url.connector";

 @Override
 protected void initTest() throws Exception {
  super.initTest();

  requestBody = new TestConnectionRequestBody();
  requestBody.setConnectionAttributes(connectionAttributes);
  requestBody.setCredentialAttributes(credentialAttributes);

  extractDataRequestBody = new ExtractDataRequestBody();
  extractDataRequestBody.setConnectionAttributes(connectionAttributes);
  extractDataRequestBody.setCredentialAttributes(credentialAttributes);
  extractDataRequestBody.setAdvancedAttributes(advancedAttributes);
  extractDataRequestBody.setInternalS3BucketDetail(internalS3BucketDetail);
  extractDataRequestBody.setFieldList(Arrays.asList("street", "city"));
 }

 @Test
 @Smoke
 public void testDataConnectorsSftp() throws Exception {
  // retry one-off network failures when connecting to source
  for (int retryCount = 1; retryCount <= 3; retryCount++) {
   try {
    var response =
      dataConnectorsHttpClient
        .client(httpUrlConnectorKey, true, cdpTenantId, coreTenantId)
        .testConnectionWithHttpInfo("SFTP", requestBody);

    assertEquals(200, response.getStatusCode());
    return;
   } catch (ApiException e) {
    log.error(
      String.format(
        "Test testDataConnectorsSftp failed [%s] times, error code: [%s], response body: [%s], response headers: [%s], cause: [%s]",
        retryCount,
        e.getCode(),
        e.getResponseBody(),
        e.getResponseHeaders(),
        e.getCause()));
    if (retryCount == 3) {
     throw e;
    } else {
     Thread.sleep(TestConstants.RETRY_DELAY);
    }
   }
  }
 }

 @Test
 @Smoke
 public void testDataConnectorsExtractDataSftp() throws Exception {
  // retry one-off network failures when connecting to source
  for (int retryCount = 1; retryCount <= 3; retryCount++) {
   try {
    var response =
      dataConnectorsHttpClient
        .client(httpUrlConnectorKey, true, cdpTenantId, coreTenantId)
        .extractDataWithHttpInfo("SFTP", "Root.csv", extractDataRequestBody);
    assertEquals(200, response.getStatusCode());
    return;
   } catch (ApiException e) {
    log.error(
      String.format(
        "Test testDataConnectorsExtractDataSftp failed [%s] times, error code: [%s], response body: [%s], response headers: [%s], cause: [%s]",
        retryCount,
        e.getCode(),
        e.getResponseBody(),
        e.getResponseHeaders(),
        e.getCause()));
    if (retryCount == 3) {
     throw e;
    } else {
     Thread.sleep(TestConstants.RETRY_DELAY);
    }
   }
  }
 }

 @Test
 @Smoke
 public void testDataConnectorsSftpNoJwt() {
  // Note that this test will fail in local dev mode because JWT validation is not required
  // locally and this test will not throw the expected exception
  Exception expectedException = null;

  try {
   dataConnectorsHttpClient
     .client(httpUrlConnectorKey, false, cdpTenantId, coreTenantId)
     .testConnectionWithHttpInfo("SFTP", requestBody);
  } catch (Exception e) {
   expectedException = e;
  }
  assertThat(expectedException).isNotNull();
  assertThat(expectedException).isInstanceOf(ApiException.class);
 }
}
to write a similar test "testDataConnectorsExtractDataSftp()" for 
public void validateAttributes(WdcOperationType WDCOperationType, Map<String, String> attributes)
   throws ConnectorException {
  switch (WDCOperationType) {
   case TEST_CONNECTION:
   case GET_OBJECTS:
   case GET_FIELDS:
   case EXTRACT_DATA:
   case PREVIEW:
   case IS_OBJECT_VALID:
    if (attributes == null
      || !attributes.containsKey(WdcConstant.DOMAIN_URL)
      || !attributes.containsKey(WdcConstant.CLIENT_ID)
      || !attributes.containsKey(WdcConstant.CLIENT_SECRET)) {
     throw new ConnectorException(
       String.valueOf(WdcErrorCode.MISSING_REQUIRED_PROPERTIES), ExceptionCategory.USER);
    }
    break;
   default:
    throw new ConnectorException(
      String.valueOf(WdcErrorCode.FUNCTION_NOT_SUPPORTED), ExceptionCategory.UNIMPLEMENTED);
  }
 }