initial integration test files

testing/.gitignore

+# Output
+target/*
+*/.pyc
+/target/

testing/indexer-test-core/pom.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.opengroup.osdu.indexer</groupId>
+    <artifactId>indexer-test-core</artifactId>
+    <version>0.0.1</version>
+
+    <properties>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <cucumber.version>1.2.5</cucumber.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.google.api-client</groupId>
+            <artifactId>google-api-client</artifactId>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.fasterxml.jackson.core</groupId>
+                    <artifactId>jackson-core</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <!-- Cucumber -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+        <dependency>
+            <groupId>info.cukes</groupId>
+            <artifactId>cucumber-java</artifactId>
+            <version>${cucumber.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>info.cukes</groupId>
+            <artifactId>cucumber-junit</artifactId>
+            <version>${cucumber.version}</version>
+        </dependency>
+
+        <!-- Gson: Java to Json conversion -->
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.jaxrs</groupId>
+            <artifactId>jackson-jaxrs-json-provider</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.glassfish</groupId>
+            <artifactId>javax.json</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.sun.jersey</groupId>
+            <artifactId>jersey-client</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.6</version>
+        </dependency>
+
+        <!--Elasticsearch-->
+        <dependency>
+            <groupId>org.elasticsearch</groupId>
+            <artifactId>elasticsearch</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.elasticsearch.client</groupId>
+            <artifactId>elasticsearch-rest-client</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.elasticsearch.client</groupId>
+            <artifactId>elasticsearch-rest-high-level-client</artifactId>
+        </dependency>
+
+        <!--Logging-->
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-to-slf4j</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-jdk14</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+    </dependencies>
+</project>
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/common/TestsBase.java

+package org.opengroup.osdu.common;
+
+import com.google.gson.Gson;
+
+import org.opengroup.osdu.models.Legal;
+import org.opengroup.osdu.models.Setup;
+import org.opengroup.osdu.models.TestIndex;
+import org.opengroup.osdu.response.ResponseBase;
+import org.opengroup.osdu.util.HTTPClient;
+
+import com.sun.jersey.api.client.ClientResponse;
+import cucumber.api.Scenario;
+import lombok.extern.java.Log;
+
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+import static org.opengroup.osdu.util.Config.*;
+
+@Log
+public abstract class TestsBase {
+
+    protected Scenario scenario;
+    protected Map<String, String> tenantMap = new HashMap<>();
+    protected HTTPClient httpClient = new HTTPClient();
+    protected Map<String, TestIndex> inputRecordMap = new HashMap<>();
+
+    public TestsBase() {
+        tenantMap.put("tenant1", getDataPartitionIdTenant1());
+        tenantMap.put("tenant2", getDataPartitionIdTenant2());
+        tenantMap.put("common", "common");
+    }
+
+    protected void setUp(List<Setup> inputList, String timeStamp) {
+        for (Setup input : inputList) {
+            TestIndex testIndex = new TestIndex();
+            testIndex.setIndex(generateActualName(input.getIndex(), timeStamp));
+            testIndex.setKind(generateActualName(input.getKind(), timeStamp));
+            testIndex.setMappingFile(input.getMappingFile());
+            testIndex.setRecordFile(input.getRecordFile());
+            List<String> dataGroup = new ArrayList<>();
+            String[] viewerGroup = input.getViewerGroup().split(",");
+            for (int i = 0; i < viewerGroup.length; i++) {
+                viewerGroup[i] = generateActualName(viewerGroup[i], timeStamp) + "." + getEntitlementsDomain();
+                dataGroup.add(viewerGroup[i]);
+            }
+            String[] ownerGroup = input.getOwnerGroup().split(",");
+            for (int i = 0; i < ownerGroup.length; i ++) {
+                ownerGroup[i] = generateActualName(ownerGroup[i], timeStamp) + "." + getEntitlementsDomain();
+                if (dataGroup.indexOf(ownerGroup[i]) > 0) {
+                    dataGroup.add(ownerGroup[i]);
+                }
+            }
+            testIndex.setViewerGroup(viewerGroup);
+            testIndex.setOwnerGroup(ownerGroup);
+            testIndex.setDataGroup(dataGroup.toArray(new String[dataGroup.size()]));
+            inputRecordMap.put(testIndex.getKind(), testIndex);
+        }
+        /******************One time setup for whole feature**************/
+        Runtime.getRuntime().addShutdownHook(new Thread() {
+            public void run() {
+                tearDown();
+            }
+        });
+        for (String kind : inputRecordMap.keySet()) {
+            TestIndex testIndex = inputRecordMap.get(kind);
+            testIndex.setupIndex();
+        }
+
+    }
+
+    /******************One time cleanup for whole feature**************/
+    public void tearDown() {
+        for (String kind : inputRecordMap.keySet()) {
+            TestIndex testIndex = inputRecordMap.get(kind);
+            testIndex.cleanupIndex();
+        }
+    }
+
+    protected abstract String getApi();
+
+    protected abstract String getHttpMethod();
+
+    protected String executeQuery(String api, String payLoad, Map<String, String> headers) {
+        ClientResponse clientResponse = httpClient.send(this.getHttpMethod(), api, payLoad, headers);
+        logCorrelationIdWithFunctionName(clientResponse.getHeaders());
+        log.info(String.format("Response status: %s, type: %s", clientResponse.getStatus(), clientResponse.getType().toString()));
+        assertEquals(MediaType.APPLICATION_JSON, clientResponse.getType().toString());
+        return clientResponse.getEntity(String.class);
+    }
+
+    protected <T extends ResponseBase> T executeQuery(String api, String payLoad, Map<String, String> headers, Class<T> typeParameterClass) {
+        ClientResponse clientResponse = httpClient.send(this.getHttpMethod(), api, payLoad, headers);
+        logCorrelationIdWithFunctionName(clientResponse.getHeaders());
+        return getResponse(clientResponse, typeParameterClass);
+    }
+
+    protected <T extends ResponseBase> T executeQuery(String payLoad, Map<String, String> headers, Class<T> typeParameterClass) {
+        ClientResponse clientResponse = httpClient.send(this.getHttpMethod(), this.getApi(), payLoad, headers);
+        logCorrelationIdWithFunctionName(clientResponse.getHeaders());
+        return getResponse(clientResponse, typeParameterClass);
+    }
+
+    private <T extends ResponseBase> T getResponse(ClientResponse clientResponse, Class<T> typeParameterClass) {
+        log.info(String.format("Response status: %s, type: %s", clientResponse.getStatus(), clientResponse.getType().toString()));
+        assertEquals(MediaType.APPLICATION_JSON, clientResponse.getType().toString());
+        String responseEntity = clientResponse.getEntity(String.class);
+
+        T response = new Gson().fromJson(responseEntity, typeParameterClass);
+        response.setHeaders(clientResponse.getHeaders());
+        response.setResponseCode(clientResponse.getStatus());
+        return response;
+    }
+
+    protected ClientResponse executeGetRequest(String api, Map<String, String> headers) {
+        return executeRequest(this.getHttpMethod(), api, headers);
+    }
+
+    protected ClientResponse executeRequest(String method, String api, Map<String, String> headers) {
+        ClientResponse clientResponse = httpClient.send(method, api, null, headers);
+        if (clientResponse.getType() != null) {
+            log.info(String.format("Response status: %s, type: %s", clientResponse.getStatus(), clientResponse.getType().toString()));
+        }
+        logCorrelationIdWithFunctionName(clientResponse.getHeaders());
+        return clientResponse;
+    }
+
+    private void logCorrelationIdWithFunctionName(MultivaluedMap<String, String> headers) {
+        log.info(String.format("Scenario Name: %s, Correlation-Id: %s", scenario.getId(), headers.get("correlation-id")));
+    }
+
+    protected String getTenantMapping(String tenant) {
+        if (tenantMap.containsKey(tenant)) {
+            return tenantMap.get(tenant);
+        }
+        return null;
+    }
+
+    protected String generateActualName(String rawName, String timeStamp) {
+        for (String tenant : tenantMap.keySet()) {
+            rawName = rawName.replaceAll(tenant, getTenantMapping(tenant));
+        }
+        return rawName.replaceAll("<timestamp>", timeStamp);
+    }
+
+    protected Legal generateLegalTag() {
+        Legal legal = new Legal();
+        String[] legalTags = {getLegalTag()};
+        legal.setLegaltags(legalTags);
+        String[] otherRelevantCountries = {getOtherRelevantDataCountries()};
+        legal.setOtherRelevantDataCountries(otherRelevantCountries);
+        return legal;
+    }
+}

testing/indexer-test-core/src/main/java/org/opengroup/osdu/models/Acl.java

+package org.opengroup.osdu.models;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class Acl {
+
+    private String[] viewers;
+
+    private String[] owners;
+
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/models/FilterInfo.java

+package org.opengroup.osdu.models;
+
+public class FilterInfo {
+    public String name;
+    public String description;
+}

testing/indexer-test-core/src/main/java/org/opengroup/osdu/models/Legal.java

+package org.opengroup.osdu.models;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Legal {
+
+    private String[] legaltags;
+
+    private String[] otherRelevantDataCountries;
+
+    @lombok.Builder.Default
+    private String status = "compliant";
+}

testing/indexer-test-core/src/main/java/org/opengroup/osdu/models/Setup.java

+package org.opengroup.osdu.models;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.Map;
+
+import org.opengroup.osdu.util.HTTPClient;
+
+@Data
+@NoArgsConstructor
+public class Setup {
+    private String tenantId;
+    private String kind;
+    private String index;
+    private String viewerGroup;
+    private String ownerGroup;
+    private String mappingFile;
+    private String recordFile;
+    private String schemaFile;
+    private HTTPClient httpClient;
+    private Map<String, String> headers;
+}

testing/indexer-test-core/src/main/java/org/opengroup/osdu/models/TestIndex.java

+package org.opengroup.osdu.models;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.reflect.TypeToken;
+import com.sun.jersey.api.client.ClientResponse;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.ws.rs.HttpMethod;
+
+import org.opengroup.osdu.util.ElasticUtils;
+import org.opengroup.osdu.util.FileHandler;
+import org.opengroup.osdu.util.HTTPClient;
+
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import static org.junit.Assert.assertEquals;
+import static org.opengroup.osdu.util.Config.*;
+
+@Data
+@NoArgsConstructor
+public class TestIndex {
+    private static final Logger LOGGER = Logger.getLogger(TestIndex.class.getName());
+    private String kind;
+    private String index;
+    private String mappingFile;
+    private String recordFile;
+    private int recordCount;
+    private String schemaFile;
+    private String[] dataGroup;
+    private String[] viewerGroup;
+    private String[] ownerGroup;
+    private HTTPClient httpClient = new HTTPClient();
+    private Map<String, String> headers = httpClient.getCommonHeader();
+    private ElasticUtils elasticUtils = new ElasticUtils();
+    private Gson gson = new Gson();
+
+    public void setupIndex() {
+        this.addIndex();
+        List<Map<String, Object>> records = getRecordsFromTestFile();
+        this.recordCount = this.elasticUtils.indexRecords(this.index, this.kind, records);
+    }
+
+    public void setupSchema() {
+        ClientResponse clientResponse = this.httpClient.send(HttpMethod.POST, getStorageBaseURL() + "schemas", this.getStorageSchemaFromJson(), headers);
+        if (clientResponse.getType() != null)
+            LOGGER.info(String.format("Response status: %s, type: %s", clientResponse.getStatus(), clientResponse.getType().toString()));
+    }
+
+    public void deleteSchema(String kind) {
+        ClientResponse clientResponse = this.httpClient.send(HttpMethod.DELETE, getStorageBaseURL() + "schemas/" + kind, null, headers);
+        assertEquals(204, clientResponse.getStatus());
+        if (clientResponse.getType() != null)
+            LOGGER.info(String.format("Response status: %s, type: %s", clientResponse.getStatus(), clientResponse.getType().toString()));
+    }
+
+    public void addIndex() {
+        this.elasticUtils.createIndex(this.index, this.getIndexMappingFromJson());
+    }
+
+    public void cleanupIndex() {
+        this.elasticUtils.deleteIndex(index);
+    }
+
+    private String getRecordFile() {
+        return String.format("%s.json", this.recordFile);
+    }
+
+    private String getMappingFile() {
+        return String.format("%s.mapping", this.mappingFile);
+    }
+
+    private String getSchemaFile() {
+        return String.format("%s.schema", this.schemaFile);
+    }
+
+    private List<Map<String, Object>> getRecordsFromTestFile() {
+        File resourcesDirectory = new File("src/test/resources");
+        try {
+            String fileContent = FileHandler.readFile(
+                    String.format("%s/testData/%s", resourcesDirectory.getAbsolutePath(), getRecordFile()));
+            List<Map<String, Object>> records = new Gson().fromJson(
+                    fileContent, new TypeToken<List<Map<String,Object>>>() {}.getType());
+
+            for (Map<String, Object> testRecord : records) {
+                testRecord.put("kind", this.kind);
+                testRecord.put("legal", generateLegalTag());
+                testRecord.put("x-acl", dataGroup);
+                Acl acl = Acl.builder().viewers(viewerGroup).owners(ownerGroup).build();
+                testRecord.put("acl", acl);
+            }
+            return records;
+        } catch (Exception ex) {
+            throw new AssertionError(ex.getMessage());
+        }
+    }
+
+    private String getIndexMappingFromJson() {
+        File resourcesDirectory = new File("src/test/resources");
+        try {
+            String fileContent = FileHandler.readFile(
+                    String.format("%s/testData/%s", resourcesDirectory.getAbsolutePath(), getMappingFile()));
+            JsonElement json = gson.fromJson(fileContent, JsonElement.class);
+            return gson.toJson(json);
+        } catch (Exception e) {
+            throw new AssertionError(e.getMessage());
+        }
+    }
+
+    private String getStorageSchemaFromJson() {
+        File resourcesDirectory = new File("src/test/resources");
+        try {
+            String fileContent = FileHandler.readFile(
+                    String.format("%s/testData/%s", resourcesDirectory.getAbsolutePath(), getSchemaFile()));
+            fileContent = fileContent.replaceAll("KIND_VAL", this.kind);
+            JsonElement json = gson.fromJson(fileContent, JsonElement.class);
+            return gson.toJson(json);
+        } catch (Exception e) {
+            throw new AssertionError(e.getMessage());
+        }
+    }
+
+    private Legal generateLegalTag() {
+        Legal legal = new Legal();
+        String[] legalTags = {getLegalTag()};
+        legal.setLegaltags(legalTags);
+        String[] otherRelevantCountries = {getOtherRelevantDataCountries()};
+        legal.setOtherRelevantDataCountries(otherRelevantCountries);
+        return legal;
+    }
+
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/response/ErrorResponseMock.java

+package org.opengroup.osdu.response;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.List;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ErrorResponseMock extends ResponseBase {
+    private List<String> errors;
+    private String code;
+    private String reason;
+    private String message;
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/response/ResponseBase.java

+package org.opengroup.osdu.response;
+
+import lombok.Data;
+
+import javax.ws.rs.core.MultivaluedMap;
+
+@Data
+public abstract class ResponseBase {
+    private int responseCode;
+    private MultivaluedMap<String, String> headers;
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/response/ResponseMock.java

+package org.opengroup.osdu.response;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ResponseMock extends ResponseBase {
+    private List<Map<String, Object>> results;
+    private List<Object> aggregations;
+    private long totalCount;
+    private String cursor;
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/step_definitions/index/deleteschema/RunTest.java

+package org.opengroup.osdu.step_definitions.index.deleteschema;
+
+import cucumber.api.CucumberOptions;
+import cucumber.api.junit.Cucumber;
+import org.junit.runner.RunWith;
+
+@RunWith(Cucumber.class)
+@CucumberOptions(
+        features = "src/test/resources/features/delete/Delete.feature",
+        glue={"classpath:org.opengroup.osdu.step_definitions/index/deleteschema"},
+        format = {"pretty", "junit:target/cucumber-reports/TEST-deleteschema.xml"})
+public class RunTest {
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/step_definitions/index/deleteschema/Steps.java

+package org.opengroup.osdu.step_definitions.index.deleteschema;
+
+import com.sun.jersey.api.client.ClientResponse;
+
+import cucumber.api.DataTable;
+import cucumber.api.Scenario;
+import cucumber.api.java.Before;
+import cucumber.api.java.en.Given;
+import cucumber.api.java.en.Then;
+import cucumber.api.java.en.When;
+
+import org.opengroup.osdu.common.TestsBase;
+import org.opengroup.osdu.models.Setup;
+import org.opengroup.osdu.models.TestIndex;
+import org.opengroup.osdu.response.ErrorResponseMock;
+import org.opengroup.osdu.util.Config;
+import org.opengroup.osdu.util.HTTPClient;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+
+public class Steps extends TestsBase {
+
+    private static String timeStamp = String.valueOf(System.currentTimeMillis());
+    private HTTPClient httpClient = new HTTPClient();
+
+    private Map<String, String> headers = httpClient.getCommonHeader();
+
+    private static boolean dunit = false;
+
+    private String deleteUrl;
+    private String kind;
+
+    private Map<String, TestIndex> inputRecordMap = new HashMap<>();
+
+    @Given("^the elastic search is initialized with the following data$")
+    public void the_elastic_search_is_initialized_with_the_following_data(DataTable dataTable) throws Throwable {
+        List<Setup> inputlist = dataTable.asList(Setup.class);
+        for (Setup input : inputlist) {
+            TestIndex testIndex = new TestIndex();
+            testIndex.setIndex(generateActualName(input.getIndex(), timeStamp));
+            testIndex.setKind(generateActualName(input.getKind(), timeStamp));
+            testIndex.setMappingFile(input.getMappingFile());
+            testIndex.setRecordFile(input.getRecordFile());
+            inputRecordMap.put(testIndex.getKind(), testIndex);
+        }
+        /******************One time setup for whole feature**************/
+        if (!dunit) {
+            Runtime.getRuntime().addShutdownHook(new Thread() {
+                public void run() {
+                    tearDown();
+                }
+            });
+            dunit = true;
+            for (String kind : inputRecordMap.keySet()) {
+                TestIndex testIndex = inputRecordMap.get(kind);
+                testIndex.setupIndex();
+            }
+        }
+    }
+
+    /******************One time cleanup for whole feature**************/
+    public void tearDown() {
+        for (String kind : inputRecordMap.keySet()) {
+            TestIndex testIndex = inputRecordMap.get(kind);
+            testIndex.cleanupIndex();
+        }
+    }
+
+    @Before
+    public void before(Scenario scenario) {
+        this.scenario = scenario;
+    }
+
+    @When("^I send a delete request with \"([^\"]*)\"$")
+    public void i_send_a_delete_request_with(String kind) throws Throwable {
+        kind = generateActualName(kind, timeStamp);
+        deleteUrl = String.format(this.getApi(), kind);
+        this.kind = kind;
+    }
+
+    @Then("^the index should get delete and I should get (\\d+) response$")
+    public void the_index_should_get_delete_and_I_should_get_response(int code) throws Throwable {
+        ClientResponse clientResponse = executeGetRequest(deleteUrl, headers);
+        assertEquals(code, clientResponse.getStatus());
+    }
+
+    @Then("^I should get ([^\"]*) response with reason: \"(.*?)\", message: \"(.*?)\" and errors: \"(.*?)\"$")
+    public void i_should_get_response_with_reason_message_and_errors(List<Integer> codes, String type, String msg,
+                                                                     String error) throws Throwable {
+        ErrorResponseMock response = executeQuery(deleteUrl, null, headers, ErrorResponseMock.class);
+        assertTrue(codes.contains(response.getResponseCode()));
+        if (response.getErrors() != null) {
+            error = generateActualName(error, timeStamp);
+            assertEquals(generateActualName(error,timeStamp), response.getErrors().get(0));
+        }
+        assertNotNull(response.getMessage());
+        assertNotNull(response.getReason());
+        assertEquals(type.toLowerCase(), response.getReason().toLowerCase());
+        assertEquals(generateActualName(msg,timeStamp), response.getMessage());
+    }
+
+    @Override
+    protected String getHttpMethod() {
+        return "DELETE";
+    }
+
+    @Override
+    protected String getApi() {
+        return Config.getSearchBaseURL() + "index/%s";
+    }
+}

testing/indexer-test-core/src/main/java/org/opengroup/osdu/step_definitions/index/getschema/RunTest.java

+package org.opengroup.osdu.step_definitions.index.getschema;
+
+import cucumber.api.CucumberOptions;
+import cucumber.api.junit.Cucumber;
+import org.junit.runner.RunWith;
+
+
+@RunWith(Cucumber.class)
+@CucumberOptions(
+        features = "src/test/resources/features/kindschema/KindSchema.feature",
+        glue = {"classpath:org.opengroup.osdu.step_definitions/index/getschema"},
+        format = {"pretty", "junit:target/cucumber-reports/TEST-getschema.xml"})
+public class RunTest {
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/step_definitions/index/getschema/Steps.java

+package org.opengroup.osdu.step_definitions.index.getschema;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+import org.opengroup.osdu.common.TestsBase;
+import org.opengroup.osdu.models.Setup;
+import org.opengroup.osdu.models.TestIndex;
+import org.opengroup.osdu.response.ErrorResponseMock;
+import org.opengroup.osdu.util.Config;
+import org.opengroup.osdu.util.HTTPClient;
+
+import com.sun.jersey.api.client.ClientResponse;
+import cucumber.api.DataTable;
+import cucumber.api.Scenario;
+import cucumber.api.java.Before;
+import cucumber.api.java.en.Given;
+import cucumber.api.java.en.Then;
+import cucumber.api.java.en.When;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class Steps extends TestsBase {
+
+    private static String timeStamp = String.valueOf(System.currentTimeMillis());
+    private static boolean dunit = false;
+    private HTTPClient httpClient = new HTTPClient();
+    private Map<String, String> headers = httpClient.getCommonHeader();
+    private Map<String, TestIndex> inputRecordMap = new HashMap<>();
+    private String schemaUrl;
+    private String kind;
+
+    @Given("^the elastic search is initialized with the following data$")
+    public void the_elastic_search_is_initialized_with_the_following_data(DataTable dataTable) throws Throwable {
+        List<Setup> inputlist = dataTable.asList(Setup.class);
+        for (Setup input : inputlist) {
+            TestIndex testIndex = new TestIndex();
+            testIndex.setIndex(generateActualName(input.getIndex(), timeStamp));
+            testIndex.setKind(generateActualName(input.getKind(), timeStamp));
+            testIndex.setMappingFile(input.getMappingFile());
+            inputRecordMap.put(testIndex.getKind(), testIndex);
+        }
+        /******************One time setup for whole feature**************/
+        if (!dunit) {
+            Runtime.getRuntime().addShutdownHook(new Thread() {
+                public void run() {
+                    tearDown();
+                }
+            });
+            dunit = true;
+            for (String kind : inputRecordMap.keySet()) {
+                TestIndex testIndex = inputRecordMap.get(kind);
+                testIndex.addIndex();
+            }
+        }
+    }
+
+    /******************One time cleanup for whole feature**************/
+    public void tearDown() {
+        for (String kind : inputRecordMap.keySet()) {
+            TestIndex testIndex = inputRecordMap.get(kind);
+            testIndex.cleanupIndex();
+        }
+    }
+
+    @Before
+    public void before(Scenario scenario) {
+        this.scenario = scenario;
+    }
+
+    @Override
+    protected String getApi() {
+        return Config.getSearchBaseURL() + "index/schema/%s";
+    }
+
+    @Override
+    protected String getHttpMethod() {
+        return "GET";
+    }
+
+    @When("^I send get schema request with \"([^\"]*)\"$")
+    public void i_send_get_schema_request_with(String kind) throws Throwable {
+        kind = generateActualName(kind, timeStamp);
+        schemaUrl = String.format(this.getApi(), kind);
+        this.kind = kind;
+    }
+
+    @When("^I send request to tenant \"(.*?)\"$")
+    public void i_send_request_to_tenant(String tenant) throws Throwable {
+        headers = HTTPClient.overrideHeader(headers, getTenantMapping(tenant));
+    }
+
+    @Then("^I should get ([^\"]*) response with reason: \"(.*?)\", message: \"(.*?)\" and errors: \"(.*?)\"$")
+    public void i_should_get_response_with_reason_message_and_errors(int responseCode, String type, String msg,
+                                                                     String error) throws Throwable {
+
+        ErrorResponseMock response = executeQuery(schemaUrl, null, headers, ErrorResponseMock.class);
+        assertEquals(responseCode, response.getResponseCode());
+        if (response.getErrors() != null) {
+            error = generateActualName(error, timeStamp);
+            assertEquals(generateActualName(error, timeStamp), response.getErrors().get(0));
+        }
+        assertEquals(type, response.getReason());
+        assertEquals(generateActualName(msg, timeStamp),response.getMessage());
+    }
+
+    @Then("^I should get (\\d+) status with response \"(.*?)\"$")
+    public void i_should_get_status_with_response(int statusCode, String response) throws Throwable {
+
+        ClientResponse schemaResponse = executeGetRequest(schemaUrl, headers);
+        assertEquals(statusCode, schemaResponse.getStatus());
+        String expectedResponse = generateActualName(response, timeStamp);
+        JsonObject expectedJson = new JsonParser().parse(expectedResponse).getAsJsonObject();
+        JsonObject actualJson = new JsonParser().parse(schemaResponse.getEntity(String.class)).getAsJsonObject();
+        assertEquals(expectedJson, actualJson);
+    }
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/step_definitions/index/mapping/RunTest.java

+package org.opengroup.osdu.step_definitions.index.mapping;
+
+import cucumber.api.CucumberOptions;
+import cucumber.api.junit.Cucumber;
+import org.junit.runner.RunWith;
+
+@RunWith(Cucumber.class)
+@CucumberOptions(
+        features = "src/test/resources/features/updateindex/UpdateIndexMapping.feature",
+        glue = {"classpath:org.opengroup.osdu.step_definitions/index/mapping"},
+        format = {"pretty", "junit:target/cucumber-reports/TEST-updateindexmapping.xml"})
+public class RunTest {
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/step_definitions/index/mapping/Steps.java

+package org.opengroup.osdu.step_definitions.index.mapping;
+
+import com.google.api.client.http.HttpMethods;
+import com.google.gson.Gson;
+import com.sun.jersey.api.client.ClientResponse;
+import cucumber.api.DataTable;
+import cucumber.api.Scenario;
+import cucumber.api.java.Before;
+import cucumber.api.java.en.Given;
+import cucumber.api.java.en.Then;
+import cucumber.api.java.en.When;
+import lombok.extern.java.Log;
+
+import java.util.*;
+
+import org.elasticsearch.cluster.metadata.MappingMetaData;
+import org.elasticsearch.common.collect.ImmutableOpenMap;
+import org.opengroup.osdu.common.TestsBase;
+import org.opengroup.osdu.models.Setup;
+import org.opengroup.osdu.request.Query;
+import org.opengroup.osdu.response.ResponseMock;
+import org.opengroup.osdu.util.Config;
+import org.opengroup.osdu.util.ElasticUtils;
+import org.opengroup.osdu.util.HTTPClient;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+@Log
+public class Steps extends TestsBase {
+    private HTTPClient httpClient;
+    private Map<String, String> headers;
+    private String fieldName;
+    private String timeStamp;
+    private static boolean dunit = false;
+    private Query requestQuery = new Query();
+    private ElasticUtils elasticUtils = new ElasticUtils();
+    public Steps() {
+        httpClient = new HTTPClient();
+        headers = httpClient.getCommonHeader();
+        fieldName="";
+        timeStamp = String.valueOf(System.currentTimeMillis());
+    }
+
+    @Given("^the elastic search is initialized with the following data$")
+    public void the_elastic_search_is_initialized_with_the_following_data(DataTable dataTable) {
+        if (!dunit) {
+            List<Setup> inputlist = dataTable.asList(Setup.class);
+            setUp(inputlist, timeStamp);
+            dunit = true;
+        }
+    }
+
+    @Before
+    public void before(Scenario scenario) {
+        this.scenario = scenario;
+    }
+
+    @Override
+    protected String getApi() {
+        return updateIndexMappingUrl;
+    }
+
+    @Override
+    protected String getHttpMethod() {
+        return "POST";
+    }
+
+    private Map<String, Object> requestPayload = new HashMap<>();
+
+    @When("^I update \"([^\"]*)\" in \"([^\"]*)\" ,\"([^\"]*)\" to enable multifield indexing$")
+    public void i_update_in_to_enable_multifield_indexing(String fieldNameVal, String index1, String index2) throws Throwable {
+        Set<String> indices = new HashSet<>();
+        System.out.println("Indices "+ index1 + index2);
+        indices.add(generateActualName(index1,timeStamp));
+        indices.add(generateActualName(index2,timeStamp));
+        fieldName=fieldNameVal;
+        requestPayload.put("indices", indices);
+        requestPayload.put("operator", "keyword");
+    }
+
+    @When("^I send request to tenant \"(.*?)\"$")
+    public void i_send_request_to_tenant(String tenant) {
+        headers = HTTPClient.overrideHeader(headers, getTenantMapping(tenant));
+    }
+
+    @Then("^I should get (\\d+) response$")
+    public void i_should_get_response(int responseCode) throws Throwable {
+        String payload = new Gson().toJson(requestPayload);
+        ClientResponse clientResponse = httpClient.send(HttpMethods.PUT, this.getApi()+"/"+this.fieldName, payload, headers);
+        assertEquals(responseCode, clientResponse.getStatus());
+    }
+
+    @When("^I send \"(.*?)\" with \"(.*?)\"$")
+    public void i_send_with(String query, String kind) {
+        requestQuery.setQuery(query);
+        requestQuery.setKind(generateActualName(kind, timeStamp));
+    }
+    @When("^I send None with \"(.*?)\"$")
+    public void i_send_None_with(String kind) {
+        requestQuery.setKind(generateActualName(kind, timeStamp));
+    }
+    @When("^I want to aggregate by \"(.*?)\"$")
+    public void i_aggregate_by(String aggField) throws Throwable {
+        requestQuery.setAggregateBy(aggField+".keyword");
+    }
+
+    @Then("^I should get in response (\\d+) records$")
+    public void i_should_get_in_response_records(int resultCount) {
+        String payload = requestQuery.toString();
+        ResponseMock response = executeQuery(searchQeueryURL,payload, this.headers, ResponseMock.class);
+        assertEquals(200, response.getResponseCode());
+        assertEquals(resultCount, response.getResults().size());
+    }
+
+    @Then("^I want to validate mapping by \"([^\"]*)\" ,\"([^\"]*)\" and \"([^\"]*)\" and \"([^\"]*)\"$")
+    public void i_want_to_validate_mapping(String indexOne, String indexTwo,String fieldName,String type) throws Throwable {
+    	ImmutableOpenMap<String, MappingMetaData> elasticMapping = elasticUtils.getMapping(generateActualName(indexOne,timeStamp));
+    	assertNotNull(elasticMapping);
+        MappingMetaData typeMapping = elasticMapping.get(type);
+        Map<String, Object> mapping = typeMapping.sourceAsMap();
+        assertNotNull(mapping);
+        String mappingJson = new Gson().toJson(mapping);
+        System.out.println(mappingJson);
+        assertTrue(mappingJson.contains(fieldName));
+        assertTrue(mappingJson.contains("raw"));
+    }
+    
+    private static String updateIndexMappingUrl = Config.getIndexerBaseURL() + "kinds";
+    private static String searchQeueryURL=Config.getSearchBaseURL() + "query";    
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/step_definitions/index/record/RunTest.java

+package org.opengroup.osdu.step_definitions.index.record;
+
+import cucumber.api.CucumberOptions;
+import cucumber.api.junit.Cucumber;
+import org.junit.runner.RunWith;
+
+
+@RunWith(Cucumber.class)
+@CucumberOptions(
+        features = "src/test/resources/features/indexrecord/IndexRecord.feature",
+        glue = {"classpath:org.opengroup.osdu.step_definitions/index/record"},
+        plugin = {"pretty", "junit:target/cucumber-reports/TEST-indexrecord.xml"})
+public class RunTest {
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/step_definitions/index/record/Steps.java

+package org.opengroup.osdu.step_definitions.index.record;
+
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.Maps;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.sun.jersey.api.client.ClientResponse;
+import cucumber.api.DataTable;
+import cucumber.api.Scenario;
+import cucumber.api.java.Before;
+import cucumber.api.java.en.Given;
+import cucumber.api.java.en.Then;
+import cucumber.api.java.en.When;
+import lombok.extern.java.Log;
+import org.elasticsearch.cluster.metadata.MappingMetaData;
+import org.elasticsearch.common.collect.ImmutableOpenMap;
+import org.opengroup.osdu.common.TestsBase;
+import org.opengroup.osdu.models.Acl;
+import org.opengroup.osdu.models.Setup;
+import org.opengroup.osdu.models.TestIndex;
+import org.opengroup.osdu.util.ElasticUtils;
+import org.opengroup.osdu.util.FileHandler;
+import org.opengroup.osdu.util.HTTPClient;
+
+import javax.ws.rs.HttpMethod;
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+import static org.opengroup.osdu.util.Config.getEntitlementsDomain;
+import static org.opengroup.osdu.util.Config.getStorageBaseURL;
+
+@Log
+public class Steps extends TestsBase {
+
+    private Map<String, TestIndex> inputIndexMap = new HashMap<>();
+    private boolean shutDownHookAdded = false;
+
+    private String timeStamp;
+    private HTTPClient httpClient;
+    private List<Map<String, Object>> records;
+    private Map<String, String> headers;
+
+    public Steps() {
+        timeStamp = String.valueOf(System.currentTimeMillis());
+        httpClient = new HTTPClient();
+        headers = httpClient.getCommonHeader();
+    }
+
+    @Given("^the schema is created with the following kind$")
+    public void the_schema_is_created_with_the_following_kind(DataTable dataTable) {
+
+        List<Setup> inputList = dataTable.asList(Setup.class);
+        for (Setup input : inputList) {
+            TestIndex testIndex = new TestIndex();
+            testIndex.setIndex(generateActualName(input.getIndex(), timeStamp));
+            testIndex.setKind(generateActualName(input.getKind(), timeStamp));
+            testIndex.setSchemaFile(input.getSchemaFile());
+            inputIndexMap.put(testIndex.getKind(), testIndex);
+        }
+
+        /******************One time setup for whole feature**************/
+        if (!shutDownHookAdded) {
+            Runtime.getRuntime().addShutdownHook(new Thread() {
+                public void run() {
+                    tearDown();
+                }
+            });
+            shutDownHookAdded = true;
+            for (String kind : inputIndexMap.keySet()) {
+                TestIndex testIndex = inputIndexMap.get(kind);
+                testIndex.setupSchema();
+            }
+        }
+    }
+
+    /******************One time cleanup for whole feature**************/
+    public void tearDown() {
+        for (String kind : inputIndexMap.keySet()) {
+            TestIndex testIndex = inputIndexMap.get(kind);
+            testIndex.cleanupIndex();
+            testIndex.deleteSchema(kind);
+        }
+        if (records != null && records.size() > 0) {
+            for (Map<String, Object> testRecord : records) {
+                String id = testRecord.get("id").toString();
+                httpClient.send(HttpMethod.DELETE, getStorageBaseURL() + "records/" + id, null, headers);
+                log.info("Deleted the records");
+            }
+        }
+    }
+
+    @Before
+    public void before(Scenario scenario) {
+        this.scenario = scenario;
+    }
+
+    @Override
+    protected String getApi() {
+        return null;
+    }
+
+    @Override
+    protected String getHttpMethod() {
+        return null;
+    }
+
+    @When("^I ingest records with the \"(.*?)\" with \"(.*?)\" for a given \"(.*?)\"$")
+    public void i_ingest_records_with_the_for_a_given(String record, String dataGroup, String kind) {
+
+        kind = generateActualName(kind, timeStamp);
+        File resourcesDirectory = new File("src/test/resources");
+        try {
+            String fileContent = FileHandler.readFile(
+                    String.format("%s/testData/%s", resourcesDirectory.getAbsolutePath(), String.format("%s.%s", record, "json")));
+            records = new Gson().fromJson(fileContent, new TypeToken<List<Map<String, Object>>>() {}.getType());
+
+            for (Map<String, Object> testRecord : records) {
+                testRecord.put("id", generateActualName(testRecord.get("id").toString(), timeStamp));
+                testRecord.put("kind", kind);
+                testRecord.put("legal", generateLegalTag());
+                String[] x_acl = {generateActualName(dataGroup,timeStamp)+"."+getEntitlementsDomain()};
+                Acl acl = Acl.builder().viewers(x_acl).owners(x_acl).build();
+                testRecord.put("acl", acl);
+            }
+            String payLoad = new Gson().toJson(records);
+            ClientResponse clientResponse = httpClient.send(HttpMethod.PUT, getStorageBaseURL() + "records", payLoad, headers);
+            assertEquals(201, clientResponse.getStatus());
+        } catch (Exception ex) {
+            throw new AssertionError(ex.getMessage());
+        }
+    }
+
+    @Then("^I should get the (\\d+) documents for the \"([^\"]*)\" in the Elastic Search$")
+    public void i_should_get_the_documents_for_the_in_the_Elastic_Search(int expectedCount, String index) throws Throwable {
+        index = generateActualName(index, timeStamp);
+        long numOfIndexedDocuments = createIndex(index);
+        assertEquals(expectedCount, numOfIndexedDocuments);
+    }
+
+
+    @Then("^I should get the elastic \"(.*?)\" for the \"([^\"]*)\" and \"([^\"]*)\" in the Elastic Search$")
+    public void i_should_get_the_elastic_for_the_tenant_testindex_timestamp_well_in_the_Elastic_Search(String expectedMapping, String type, String index) throws Throwable {
+        index = generateActualName(index, timeStamp);
+        ElasticUtils elasticUtils = new ElasticUtils();
+        ImmutableOpenMap<String, MappingMetaData> elasticMapping = elasticUtils.getMapping(index);
+        assertNotNull(elasticMapping);
+
+        MappingMetaData typeMapping = elasticMapping.get(type);
+        Map<String, Object> mapping = typeMapping.sourceAsMap();
+        assertNotNull(mapping);
+        assertTrue(areJsonEqual(expectedMapping, mapping.toString()));
+    }
+
+    @Then("^I should get the (\\d+) documents for the \"([^\"]*)\" in the Elastic Search with out \"(.*?)\"$")
+    public void iShouldGetTheNumberDocumentsForTheIndexInTheElasticSearchWithOutSkippedAttribute(int expectedCount, String index, String skippedAttributes) throws Throwable {
+        index = generateActualName(index, timeStamp);
+        ElasticUtils elasticUtils = new ElasticUtils();
+        long numOfIndexedDocuments = createIndex(index);
+        long documentCountByQuery = elasticUtils.fetchRecordsByExistQuery(index, skippedAttributes);
+        assertEquals(expectedCount, documentCountByQuery);
+    }
+
+    private long createIndex(String index) throws InterruptedException, IOException {
+        ElasticUtils elasticUtils = new ElasticUtils();
+        long numOfIndexedDocuments = 0;
+        int iterator;
+
+        // index.refresh_interval is set to default 30s, wait for 40s initially
+        Thread.sleep(40000);
+
+        for (iterator = 0; iterator < 20; iterator++) {
+
+            numOfIndexedDocuments = elasticUtils.fetchRecords(index);
+            if (numOfIndexedDocuments > 0) {
+                log.info(String.format("index: %s | attempts: %s | documents acknowledged by elastic: %s", index, iterator, numOfIndexedDocuments));
+                break;
+            } else {
+                log.info(String.format("index: %s | documents acknowledged by elastic: %s", index, numOfIndexedDocuments));
+                Thread.sleep(5000);
+            }
+
+            if ((iterator + 1) % 5 == 0) elasticUtils.refreshIndex(index);
+        }
+        if (iterator >= 20) {
+            fail(String.format("index not created after waiting for %s seconds", ((40000 + iterator * 5000) / 1000)));
+        }
+        return numOfIndexedDocuments;
+    }
+
+    private Boolean areJsonEqual(String firstJson, String secondJson) {
+        Gson gson = new Gson();
+        Type mapType = new TypeToken<Map<String, Object>>() {}.getType();
+        Map<String, Object> firstMap = gson.fromJson(firstJson, mapType);
+        Map<String, Object> secondMap = gson.fromJson(secondJson, mapType);
+
+        MapDifference<String, Object> result = Maps.difference(firstMap, secondMap);
+        if (result != null && result.entriesDiffering().isEmpty()) return true;
+        log.info(String.format("difference: %s", result.entriesDiffering()));
+        return false;
+    }
+}
\ No newline at end of file

testing/indexer-test-core/src/main/java/org/opengroup/osdu/util/Config.java

+package org.opengroup.osdu.util;
+
+public class Config {
+
+    private static final String DEFAULT_ELASTIC_HOST = "";
+    private static final String DEFAULT_ELASTIC_USER_NAME = "";
+    private static final String DEFAULT_ELASTIC_PASSWORD = "";
+    static final int PORT = 9243;
+
+    private static final String DEFAULT_INDEXER_HOST = "";
+    private static final String DEFAULT_SEARCH_HOST = "";
+    private static final String DEFAULT_STORAGE_HOST = "";
+    private static final String DEFAULT_DATA_PARTITION_ID_TENANT1 = "";
+    private static final String DEFAULT_DATA_PARTITION_ID_TENANT2 = "";
+    private static final String DEFAULT_SEARCH_INTEGRATION_TESTER = "";
+    private static final String DEFAULT_SEARCH_ON_BEHALF_INTEGRATION_TESTER = "";
+
+    private static final String DEFAULT_TARGET_AUDIENCE = "";
+
+    private static final String DEFAULT_LEGAL_TAG = "";
+    private static final String DEFAULT_OTHER_RELEVANT_DATA_COUNTRIES = "";
+
+    private static final String DEFAULT_ENTITLEMENTS_DOMAIN = "";
+
+
+    public static String getOtherRelevantDataCountries() {
+        return getEnvironmentVariableOrDefaultValue("OTHER_RELEVANT_DATA_COUNTRIES", DEFAULT_OTHER_RELEVANT_DATA_COUNTRIES);
+    }
+
+    public static String getLegalTag() {
+        return getEnvironmentVariableOrDefaultValue("LEGAL_TAG", DEFAULT_LEGAL_TAG);
+    }
+
+    public static String getTargetAudience() {
+        return getEnvironmentVariableOrDefaultValue("INTEGRATION_TEST_AUDIENCE", DEFAULT_TARGET_AUDIENCE);
+    }
+
+    public static String getKeyValue() {
+        return getEnvironmentVariableOrDefaultValue("SEARCH_INTEGRATION_TESTER", DEFAULT_SEARCH_INTEGRATION_TESTER);
+    }
+
+    public static String getOnBehalfKeyValue() {
+        return getEnvironmentVariableOrDefaultValue("SEARCH_ON_BEHALF_INTEGRATION_TESTER", DEFAULT_SEARCH_ON_BEHALF_INTEGRATION_TESTER);
+    }
+
+    public static String getDataPartitionIdTenant1() {
+        return getEnvironmentVariableOrDefaultValue("DEFAULT_DATA_PARTITION_ID_TENANT1", DEFAULT_DATA_PARTITION_ID_TENANT1);
+    }
+
+    public static String getDataPartitionIdTenant2() {
+        return getEnvironmentVariableOrDefaultValue("DEFAULT_DATA_PARTITION_ID_TENANT2", DEFAULT_DATA_PARTITION_ID_TENANT2);
+    }
+
+    public static String getUserName() {
+        return getEnvironmentVariableOrDefaultValue("ELASTIC_USER_NAME", DEFAULT_ELASTIC_USER_NAME);
+    }
+
+    public static String getPassword() {
+        return getEnvironmentVariableOrDefaultValue("ELASTIC_PASSWORD", DEFAULT_ELASTIC_PASSWORD);
+    }
+
+    public static String getElasticHost() {
+        return getEnvironmentVariableOrDefaultValue("ELASTIC_HOST", DEFAULT_ELASTIC_HOST);
+    }
+
+    public static String getIndexerBaseURL() {
+        return getEnvironmentVariableOrDefaultValue("INDEXER_HOST", DEFAULT_INDEXER_HOST);
+    }
+
+    public static String getSearchBaseURL() {
+        return getEnvironmentVariableOrDefaultValue("SEARCH_HOST", DEFAULT_SEARCH_HOST);
+    }
+
+    public static String getStorageBaseURL() {
+        return getEnvironmentVariableOrDefaultValue("STORAGE_HOST", DEFAULT_STORAGE_HOST);
+    }
+
+    public static String getEntitlementsDomain() {
+        return getEnvironmentVariableOrDefaultValue("ENTITLEMENTS_DOMAIN", DEFAULT_ENTITLEMENTS_DOMAIN);
+    }
+
+    private static String getEnvironmentVariableOrDefaultValue(String key, String defaultValue) {
+        String environmentVariable = getEnvironmentVariable(key);
+        if (environmentVariable == null) {
+            environmentVariable = defaultValue;
+        }
+        return environmentVariable;
+    }
+
+    private static String getEnvironmentVariable(String propertyKey) {
+        return System.getProperty(propertyKey, System.getenv(propertyKey));
+    }
+}