diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index dfcb220603fdc91c801a18240354072a80892bdb..a85d0f780a08030cc9a8cd05db60a8493c28318e 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -66,6 +66,8 @@ include:
   - project: "osdu/platform/ci-cd-pipelines"
     file: "publishing/pages.yml"
 
+  - local: "devops/core-plus/pipeline.yml"
+
 .maven:
   image: maven:3.9.3-eclipse-temurin-17
   tags: ['osdu-medium']
diff --git a/README.md b/README.md
index b2debdd6810e373911729c3ff7da869536542398..2d28d08f06f08cf57e53d7373b1be38a26a6281c 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,12 @@
 
 The Partition service is responsible for creating and retrieving partition specific properties on behalf of other services whether they are secret values or not. It is a Maven multi-module project with each cloud implementation placed in its submodule.
 
+## Community Implementation
+It is containing an Open-Source version with os-osm Driver containing the postgres db for consumption. As of now the code is not having any authentication for core-plus as it is not having the infra for authentication.
+So, currently it's only enough to run and consume the service locally, for development and understanding purpose.
+
+One could either spin up a postgres docker container locally, and use along with local partition service code. Or else, fetch the container image for postgres service and Partition service both and then use them. More details [here](./README.md#running-locally---partition-core-plus) 
+
 ## Running Locally - AWS
 
 Instructions for running the AWS implementation locally can be found [here](./provider/partition-aws/README.md)
@@ -16,6 +22,9 @@ Instructions for running the Google Cloud implementation locally can be found [h
 
 ## Running Locally - IBM
 
+## Running Locally - Partition Core Plus
+Instructions for running the Partion Core Plus can be found [here](./partition-core-plus/README.md)
+
 ## Running Integration Tests
 
 Instructions for running the integration tests can be found [here](./testing/README.md)
diff --git a/devops/core-plus/build/Dockerfile b/devops/core-plus/build/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..c9b1bc9f04e8c28c10df0273ab4bbb48d6df98b2
--- /dev/null
+++ b/devops/core-plus/build/Dockerfile
@@ -0,0 +1,11 @@
+FROM azul/zulu-openjdk:17
+WORKDIR /app
+ARG PORT
+ENV PORT $PORT
+
+EXPOSE ${PORT}
+
+# Copy the jar to the production image from the builder stage.
+COPY partition-core-plus/target/partition-core-plus-*-spring-boot.jar /partition-core-plus.jar
+
+ENTRYPOINT ["java","-jar","/partition-core-plus.jar"]
diff --git a/devops/core-plus/pipeline.yml b/devops/core-plus/pipeline.yml
new file mode 100644
index 0000000000000000000000000000000000000000..55d7a245d8db0032ace4522b63fb1ebb12abd433
--- /dev/null
+++ b/devops/core-plus/pipeline.yml
@@ -0,0 +1,78 @@
+core-plus-containerize:
+  stage: containerize
+  needs: ["compile-and-unit-test"]
+  tags: ["osdu-small"]
+  image: docker:19.03
+  cache: {}
+  variables:
+    BUILD_ARGS: "--build-arg PORT=$SERVICE_PORT"
+    BUILD_PATH: "devops/core-plus/build/Dockerfile"
+    CUSTOM_PROJECT_NAME: "partition-core-plus"
+    IMAGE_NAME: ${CUSTOM_PROJECT_NAME}-${CI_COMMIT_REF_SLUG}:${CI_COMMIT_SHA}
+  script:
+    - echo building $CI_REGISTRY_IMAGE:$IMAGE_NAME
+    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+    - docker build -t $CI_REGISTRY_IMAGE/$IMAGE_NAME -f $BUILD_PATH $BUILD_ARGS .
+    - docker push $CI_REGISTRY_IMAGE/$IMAGE_NAME
+  only:
+    variables:
+      - $PROTECTED == '1'
+
+core-plus-tests:
+  tags: [ "osdu-medium" ]
+  extends:
+    - .maven
+  stage: integration
+  needs: [ "compile-and-unit-test", "core-plus-containerize" ]
+  retry: 1
+  services:
+    - name: postgres
+      command:
+        ["postgres", "-c", "shared_buffers=256MB", "-c", "max_connections=200"]
+    - name: ${CI_REGISTRY_IMAGE}/${CUSTOM_PROJECT_NAME}-${CI_COMMIT_REF_SLUG}:${CI_COMMIT_SHA}
+      alias: partition-service-image
+  variables:
+    PARTITION_POSTGRESQL_DB_NAME: partition_db  #Used from bootstrapping script
+    PARTITION_POSTGRESQL_USERNAME: usr_partition_pg #Used from bootstrapping script
+    PARTITION_POSTGRESQL_PASSWORD: partition_pg #Used from bootstrapping script
+    POSTGRESQL_PORT: 5432 #used from the docker script
+    POSTGRESQL_HOST: postgres #used from the docker script
+    POSTGRESQL_USERNAME: postgres #used from the docker script
+    POSTGRES_PASSWORD: $POSTGRES_PASSWORD #used to start the postgres service alongside the runner
+    POSTGRESQL_DATABASE: postgres #default postgres database for scripts to connect
+    POSTGRESQL_PASSWORD: $POSTGRES_PASSWORD #password for above db
+    TEST_OPENID_PROVIDER_CLIENT_ID: integration-tester #integration testing
+    TEST_OPENID_PROVIDER_CLIENT_SECRET: $GC_OPENID_PROVIDER_CLIENT_SECRET #integration testing
+    TEST_NO_ACCESS_OPENID_PROVIDER_CLIENT_ID: no-access-tester #integration testing
+    TEST_NO_ACCESS_OPENID_PROVIDER_CLIENT_SECRET: $GC_NO_ACCESS_OPENID_PROVIDER_CLIENT_SECRET #integration testing
+    TEST_OPENID_PROVIDER_URL: https://keycloak.ref.gcp.gnrg-osdu.projects.epam.com/realms/osdu #token provider for testing config, need to change it later
+    DATA_PARTITION_ID: test-partition #for default configs
+    CUSTOM_PROJECT_NAME: "partition-core-plus"
+    #required for integration tests
+    CLIENT_TENANT: osdu #int tests
+    ENVIRONMENT: dev #if this is not specified, it just assumes that the service is running locally
+    PARTITION_BASE_URL: http://partition-service-image:8080/ #url where integration tests are hitting
+    #CI_DEBUG_SERVICES: "true" #flag for debugging the services in the runner
+    PARTITION_POSTGRES_URL: $PARTITION_POSTGRES_URL
+  script:
+    - echo "--- Install psql ---"
+    - apt-get update && apt-get install -y postgresql-client libpq-dev jq
+    - echo "--- Bootstrap tables ---"
+    - chmod +x devops/core-plus/test/bootstrap.sh
+    - devops/core-plus/test/bootstrap.sh
+    - echo "--- Run integration tests ---"
+    - >
+      $MAVEN_BUILD . test-results.log
+      verify -DdisableXmlReport=true
+      --quiet
+      --file testing/pom.xml
+      --projects partition-test-core,partition-test-core-plus
+      --update-snapshots
+  artifacts:
+    when: always
+    paths:
+      - test-results.log
+    expire_in: 1 days
+  only:
+    variables:
+      - $PROTECTED == '1'
diff --git a/devops/core-plus/test/bootstrap.sh b/devops/core-plus/test/bootstrap.sh
new file mode 100644
index 0000000000000000000000000000000000000000..892e8f906f579456f153ff0ae97d9f9055ffc00f
--- /dev/null
+++ b/devops/core-plus/test/bootstrap.sh
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+
+set -ex
+
+substitute_values() {
+    cat << EOF > ./valuesForSubstitution.json
+{
+"<DATA_PARTITION_ID>": "${DATA_PARTITION_ID}",
+"<PARTITION_POSTGRESQL_DB_NAME>": "${PARTITION_POSTGRESQL_DB_NAME}",
+"<PARTITION_POSTGRESQL_USERNAME>": "${PARTITION_POSTGRESQL_USERNAME}",
+"<PARTITION_POSTGRESQL_PASSWORD>": "${PARTITION_POSTGRESQL_PASSWORD}"
+}
+EOF
+
+    # shellcheck disable=SC2207
+    KEYS=( $(jq -r 'keys_unsorted[]' ./valuesForSubstitution.json) )
+    # shellcheck disable=SC2207
+    VALUES=( $(jq -r 'values[]' ./valuesForSubstitution.json) )
+
+    for i in "${!KEYS[@]}"; do
+    find ./ -type f -exec sed -i -e "s/${KEYS[$i]}/${VALUES[$i]}/g" {} \;
+    done
+
+}
+
+execute_sql_scripts() {
+    export PGPASSWORD=${POSTGRESQL_PASSWORD}
+    psql -h "${POSTGRESQL_HOST}" -U "${POSTGRESQL_USERNAME}" -p "${POSTGRESQL_PORT}" -f "devops/core-plus/test/bootstrap.sql"
+}
+
+# General connection variables
+source devops/core-plus/test/validate-env.sh "DATA_PARTITION_ID"
+
+# Service users and passwords
+source devops/core-plus/test/validate-env.sh "PARTITION_POSTGRESQL_DB_NAME"
+source devops/core-plus/test/validate-env.sh "PARTITION_POSTGRESQL_USERNAME"
+source devops/core-plus/test/validate-env.sh "PARTITION_POSTGRESQL_PASSWORD"
+source devops/core-plus/test/validate-env.sh "POSTGRESQL_HOST"
+source devops/core-plus/test/validate-env.sh "POSTGRESQL_PORT"
+source devops/core-plus/test/validate-env.sh "POSTGRESQL_USERNAME"
+source devops/core-plus/test/validate-env.sh "POSTGRESQL_PASSWORD"
+source devops/core-plus/test/validate-env.sh "POSTGRESQL_DATABASE"
+substitute_values
+execute_sql_scripts
+
+echo "Done bootstrapping the env"
diff --git a/devops/core-plus/test/bootstrap.sql b/devops/core-plus/test/bootstrap.sql
new file mode 100644
index 0000000000000000000000000000000000000000..612df0259d94e3479df37d8749c0aed4b8a83ba5
--- /dev/null
+++ b/devops/core-plus/test/bootstrap.sql
@@ -0,0 +1,19 @@
+CREATE USER <PARTITION_POSTGRESQL_USERNAME> WITH PASSWORD '<PARTITION_POSTGRESQL_PASSWORD>';
+GRANT <PARTITION_POSTGRESQL_USERNAME> TO postgres;
+CREATE DATABASE <PARTITION_POSTGRESQL_DB_NAME> OWNER <PARTITION_POSTGRESQL_USERNAME>;
+
+\c "<PARTITION_POSTGRESQL_DB_NAME>";
+
+CREATE SCHEMA IF NOT EXISTS partition AUTHORIZATION <PARTITION_POSTGRESQL_USERNAME>;
+
+CREATE TABLE IF NOT EXISTS partition."PartitionProperty"(
+    id text COLLATE pg_catalog."default" NOT NULL,
+    pk bigint NOT NULL GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+    data jsonb NOT NULL,
+    CONSTRAINT PartitionProperty UNIQUE (id)
+);
+
+ALTER TABLE
+    partition."PartitionProperty" OWNER to <PARTITION_POSTGRESQL_USERNAME>;
+
+CREATE INDEX IF NOT EXISTS PartitionProperty_datagin ON partition."PartitionProperty" USING GIN (data);
diff --git a/devops/core-plus/test/validate-env.sh b/devops/core-plus/test/validate-env.sh
new file mode 100644
index 0000000000000000000000000000000000000000..dba3a02600cc860bebb65f8ebfc846f1c828035c
--- /dev/null
+++ b/devops/core-plus/test/validate-env.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+#  Copyright 2020 Google LLC
+#  Copyright 2017-2019, Schlumberger
+#  Copyright 2022 EPAM
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+set -e
+set +x
+
+ENV_VAR_NAME=$1
+
+if [ "${!ENV_VAR_NAME}" = "" ]
+then
+    echo "Missing environment variable '$ENV_VAR_NAME'. Please provide all variables and try again"
+    { set -x ;} 2> /dev/null # enable output
+    exit 1
+fi
+
+set -x
diff --git a/partition-core-plus/README.md b/partition-core-plus/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..a374649da6d025f53c64bffbebbf62a05d1906bc
--- /dev/null
+++ b/partition-core-plus/README.md
@@ -0,0 +1,55 @@
+## Running the Partition Core Plus locally
+1. Run the basic postgres docker container with default values:
+
+`docker run --name basic-postgres --rm -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=4y7sV96vA9wv46VR -e PGDATA=/var/lib/postgresql/data/pgdata -v /tmp:/var/lib/postgresql/data -p 5432:5432 -it postgres:14.1-alpine`
+
+It will pull the image if not present locally, and will run it with local mounted tmp  folder. It retains the tables created, you can choose a folder of your choice.
+
+`After the container is running and waiting for connections, below should be seen on console:
+2023-09-28 11:31:46.372 UTC [1] LOG:  listening on IPv6 address "::", port 5432
+2023-09-28 11:31:46.382 UTC [1] LOG:  listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432"
+2023-09-28 11:31:46.384 UTC [21] LOG:  database system was shut down at 2023-09-28 11:31:42 UTC
+2023-09-28 11:31:46.386 UTC [1] LOG:  database system is ready to accept connections`
+
+2. Table creations: After postgres container is running, one can log in to this container, and create the tables required by the partition service like below:
+
+* Connect to the postgres container in shell `docker exec -it basic-postgres /bin/sh`
+
+* After that, login to postgres cli: `psql --username postgres`
+
+* To list existing tables, u can run `\l` command(it is letter l, and not number 1).
+
+* Create the below table required for running the partition service, you can change these names and then change the env vars as well injected into the Partition Service docker container in the next step.
+
+```CREATE USER usr_partition_pg WITH PASSWORD 'partition_pg';
+GRANT usr_partition_pg TO postgres;
+CREATE DATABASE partition_db OWNER usr_partition_pg;
+
+\c "partition_db";
+
+CREATE SCHEMA IF NOT EXISTS partition AUTHORIZATION usr_partition_pg;
+
+CREATE TABLE IF NOT EXISTS partition."PartitionProperty"(
+id text COLLATE pg_catalog."default" NOT NULL,
+pk bigint NOT NULL GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+data jsonb NOT NULL,
+CONSTRAINT PartitionProperty UNIQUE (id)
+);
+
+ALTER TABLE partition."PartitionProperty" OWNER to usr_partition_pg;
+
+CREATE INDEX IF NOT EXISTS PartitionProperty_datagin ON partition."PartitionProperty" USING GIN (data);
+```
+
+3. After the required tables are created, launch the partition service image locally with below command:
+
+`docker run --name partiton_service --env ./env-partition-core-plus.txt -p 8080:8080 community.opengroup.org:5555/osdu/platform/system/partition/partition-core-plus-dk-az-community-ref-impl:3a341a939fe74889c3b99a5271e2977d84925c74`
+
+* For this command to work, create a file with below data in the same folder from where you're executing the above command (variables are in sync with what was created in point number 2):
+
+`PARTITION_POSTGRES_URL=jdbc:postgresql://172.17.0.1:5432/partition_db
+PARTITION_POSTGRESQL_USERNAME=usr_partition_pg
+PARTITION_POSTGRESQL_PASSWORD=partition_pg
+dataPartitionId=test-partition`
+
+* Now, you can hit the Partition service from Postman to work on partition service locally.
diff --git a/partition-core-plus/pom.xml b/partition-core-plus/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..7613c71317bb125ae1662b2886c836ccf1ad9316
--- /dev/null
+++ b/partition-core-plus/pom.xml
@@ -0,0 +1,122 @@
+<?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>
+    <parent>
+        <groupId>org.opengroup.osdu</groupId>
+        <artifactId>partition</artifactId>
+        <version>0.24.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>partition-core-plus</artifactId>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-dependencies</artifactId>
+                <version>2.7.10</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+    <dependencies>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.opengroup.osdu</groupId>
+            <artifactId>os-osm.postgres</artifactId>
+            <version>0.24.0-rc7</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.cloud</groupId>
+            <artifactId>google-cloud-datastore</artifactId>
+            <version>2.13.5</version>
+        </dependency>
+        <dependency>
+            <groupId>org.opengroup.osdu</groupId>
+            <artifactId>partition-core</artifactId>
+            <version>0.24.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <version>3.6.0</version>
+                <executions>
+                    <execution>
+                        <id>get</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>get</goal>
+                        </goals>
+                        <configuration>
+                            <groupId>org.opengroup.osdu</groupId>
+                            <artifactId>os-osm.postgres</artifactId>
+                            <version>0.24.0-rc6</version>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                        <configuration>
+                            <classifier>spring-boot</classifier>
+                            <mainClass>org.opengroup.osdu.partition.coreplus.PartitionApplication
+                            </mainClass>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.22.2</version>
+                <configuration>
+                    <argLine>@{argLine} --add-opens java.base/java.lang=ALL_UNNAMED</argLine>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.8</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>report</id>
+                        <phase>prepare-package</phase>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/PartitionApplication.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/PartitionApplication.java
new file mode 100644
index 0000000000000000000000000000000000000000..aac7fe6b154a3a05d8b91ba828bf1823158ee71b
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/PartitionApplication.java
@@ -0,0 +1,36 @@
+// Copyright 2017-2020, Schlumberger
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package org.opengroup.osdu.partition.coreplus;
+
+import org.opengroup.osdu.core.osm.postgresql.PgTenantOsmDestinationResolver;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.FilterType;
+import org.springframework.context.annotation.PropertySource;
+
+@ComponentScan(basePackages = {"org.opengroup.osdu"}, excludeFilters =
+@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {
+        PgTenantOsmDestinationResolver.class
+}
+))
+@SpringBootApplication
+@PropertySource("classpath:swagger.properties")
+public class PartitionApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(PartitionApplication.class, args);
+    }
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/cache/VmCacheConfiguration.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/cache/VmCacheConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b9d6ed851f8ed17fd9e6e396631b2b66dcf8ede
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/cache/VmCacheConfiguration.java
@@ -0,0 +1,48 @@
+/*
+  Copyright 2002-2021 Google LLC
+  Copyright 2002-2021 EPAM Systems, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.coreplus.cache;
+
+import lombok.RequiredArgsConstructor;
+import org.opengroup.osdu.core.common.cache.VmCache;
+import org.opengroup.osdu.partition.model.PartitionInfo;
+import org.opengroup.osdu.partition.coreplus.config.PropertiesConfiguration;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.List;
+
+@Configuration
+@RequiredArgsConstructor
+public class VmCacheConfiguration {
+
+  private final PropertiesConfiguration properties;
+
+  @Bean(name = "partitionListCache")
+  public VmCache<String, List<String>> partitionListCache() {
+    return new VmCache<>(this.properties.getCacheExpiration() * 60,
+        this.properties.getCacheMaxSize());
+  }
+
+  @ConfigurationProperties
+  @Bean(name = "partitionServiceCache")
+  public VmCache<String, PartitionInfo> partitionServiceCache() {
+    return new VmCache<>(this.properties.getCacheExpiration() * 60,
+        this.properties.getCacheMaxSize());
+  }
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/config/PropertiesConfiguration.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/config/PropertiesConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..193c749d6baf1b8e553192cb48d2d40a7a5641b3
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/config/PropertiesConfiguration.java
@@ -0,0 +1,37 @@
+/*
+ Copyright 2002-2022 Google LLC
+ Copyright 2002-2022 EPAM Systems, Inc
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+package org.opengroup.osdu.partition.coreplus.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ConfigurationProperties
+@Data
+public class PropertiesConfiguration {
+
+  private String dataPartitionId;
+  private int cacheExpiration;
+
+  private int cacheMaxSize;
+
+  private String partitionPropertyKind;
+
+  private String partitionNamespace;
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/mapper/TypeMapperImpl.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/mapper/TypeMapperImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..45d67d8756cb3827362e7d755e6e793d6c2ee976
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/mapper/TypeMapperImpl.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2020-2021 Google LLC
+ * Copyright 2020-2021 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.coreplus.mapper;
+
+import com.google.cloud.datastore.Key;
+import org.opengroup.osdu.core.osm.core.persistence.IdentityTranslator;
+import org.opengroup.osdu.core.osm.core.translate.Instrumentation;
+import org.opengroup.osdu.core.osm.core.translate.TypeMapper;
+import org.opengroup.osdu.partition.coreplus.model.PartitionPropertyEntity;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Scope;
+import org.springframework.stereotype.Component;
+
+import java.util.Collections;
+import java.util.HashMap;
+
+import static org.springframework.beans.factory.config.BeanDefinition.SCOPE_SINGLETON;
+
+@Component
+@Scope(SCOPE_SINGLETON)
+@ConditionalOnProperty(name = "osmDriver")
+public class TypeMapperImpl extends TypeMapper {
+    public TypeMapperImpl(){
+        super(java.util.List.of(
+                new Instrumentation<>(PartitionPropertyEntity.class,
+                        new HashMap<String, String>() {{
+                            put("partitionId", "partition_id");
+                        }},
+                        java.util.Map.of(),
+                        new IdentityTranslator<>(
+                                PartitionPropertyEntity::getId,
+                                (p, o) -> p.setId(((Key)o).getName())
+                        ),
+                        Collections.singletonList("id")
+                ))
+        );
+    }
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/model/PartitionPropertyEntity.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/model/PartitionPropertyEntity.java
new file mode 100644
index 0000000000000000000000000000000000000000..27bc7ac1567793ab9529ff739ec60bbde3f0dddd
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/model/PartitionPropertyEntity.java
@@ -0,0 +1,48 @@
+/*
+  Copyright 2002-2021 Google LLC
+  Copyright 2002-2021 EPAM Systems, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.coreplus.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.opengroup.osdu.partition.model.Property;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class PartitionPropertyEntity {
+
+    private String id;
+
+    private String partitionId;
+
+    private String name;
+
+    private Boolean sensitive;
+
+    private Object value;
+
+
+    public PartitionPropertyEntity(String partitionId, String name, Property property) {
+        this.id = name + "-" + partitionId;
+        this.partitionId = partitionId;
+        this.name = name;
+        this.sensitive = property.isSensitive();
+        this.value = property.getValue();
+    }
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/osm/config/provider/OsmPartitionDestinationProvider.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/osm/config/provider/OsmPartitionDestinationProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..a23a451b277fdc9c75af27d74c4553e5e5ca1306
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/osm/config/provider/OsmPartitionDestinationProvider.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2020-2021 Google LLC
+ * Copyright 2020-2021 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.coreplus.osm.config.provider;
+
+import lombok.RequiredArgsConstructor;
+import org.opengroup.osdu.core.osm.core.model.Destination;
+import org.opengroup.osdu.core.osm.core.model.Kind;
+import org.opengroup.osdu.core.osm.core.model.Namespace;
+import org.opengroup.osdu.partition.coreplus.config.PropertiesConfiguration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.stereotype.Service;
+
+@Primary
+@Service
+@RequiredArgsConstructor
+public class OsmPartitionDestinationProvider {
+
+    private final PropertiesConfiguration config;
+
+    public Destination getDestination() {
+        return Destination.builder()
+                .partitionId(config.getDataPartitionId())
+                .namespace(new Namespace(config.getPartitionNamespace()))
+                .kind(new Kind(config.getPartitionPropertyKind()))
+                .build();
+    }
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/osm/repository/OsmPartitionPropertyRepository.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/osm/repository/OsmPartitionPropertyRepository.java
new file mode 100644
index 0000000000000000000000000000000000000000..919015710a03e0054a1402ec7f15e939ae61de80
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/osm/repository/OsmPartitionPropertyRepository.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2020-2021 Google LLC
+ * Copyright 2020-2021 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.coreplus.osm.repository;
+
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.ObjectUtils;
+import org.opengroup.osdu.core.common.model.http.AppException;
+import org.opengroup.osdu.core.osm.core.model.Destination;
+import org.opengroup.osdu.core.osm.core.model.query.GetQuery;
+import org.opengroup.osdu.core.osm.core.model.where.Where;
+import org.opengroup.osdu.core.osm.core.service.Context;
+import org.opengroup.osdu.core.osm.core.service.Transaction;
+import org.opengroup.osdu.core.osm.core.translate.TranslatorException;
+import org.opengroup.osdu.partition.coreplus.model.PartitionPropertyEntity;
+import org.opengroup.osdu.partition.coreplus.osm.config.provider.OsmPartitionDestinationProvider;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.opengroup.osdu.core.osm.core.model.where.predicate.Eq.eq;
+import static org.springframework.http.HttpStatus.INTERNAL_SERVER_ERROR;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+@ConditionalOnProperty("osmDriver")
+public class OsmPartitionPropertyRepository {
+
+    public static final String PARTITION_ID_FILED = "partition_id";
+    public static final String PROPERTY_ID = "id";
+    private final OsmPartitionDestinationProvider osmPartitionDestinationProvider;
+    private final Context context;
+
+
+    public Optional<List<PartitionPropertyEntity>> findByPartitionId(String partitionId) {
+        List<PartitionPropertyEntity> properties =
+                context.getResultsAsList(buildPartitionEntityQueryBy(eq(PARTITION_ID_FILED, partitionId)));
+        return (CollectionUtils.isEmpty(properties)) ?
+                Optional.empty():
+                Optional.of(properties);
+    }
+
+    public PartitionPropertyEntity findByPartitionIdAndName(String partitionId, String key) {
+        return context.getOne(buildPartitionEntityQueryBy(eq(PROPERTY_ID, partitionId + "-" + key)));
+    }
+
+    public List<String> getAllPartitions() {
+        return context.getResultsAsList(
+                    new GetQuery<>(PartitionPropertyEntity.class, osmPartitionDestinationProvider.getDestination()))
+                .stream()
+                .map(PartitionPropertyEntity::getPartitionId)
+                .distinct()
+                .collect(Collectors.toList());
+    }
+
+    public void deleteByPartitionId(String partitionId) {
+        Destination destination = osmPartitionDestinationProvider.getDestination();
+        Transaction tx = null;
+        try{
+
+            tx = context.beginTransaction(destination);
+
+            context.delete(
+                    PartitionPropertyEntity.class,
+                    osmPartitionDestinationProvider.getDestination(),
+                    eq(PARTITION_ID_FILED, partitionId));
+
+            tx.commitIfActive();
+        } catch (TranslatorException e) {
+            log.error("Error during partition delete", e);
+            throw new AppException(
+                    INTERNAL_SERVER_ERROR.value(),
+                    INTERNAL_SERVER_ERROR.getReasonPhrase(),
+                    "Error during partition delete");
+        } finally {
+            if (ObjectUtils.isNotEmpty(tx)){
+                tx.rollbackIfActive();
+            }
+        }
+    }
+
+    public void saveAll(List<PartitionPropertyEntity> partitionProperties) {
+        Destination destination = osmPartitionDestinationProvider.getDestination();
+        Transaction tx = null;
+        try{
+            tx = context.beginTransaction(destination);
+            for (PartitionPropertyEntity entity : partitionProperties){
+                context.upsert(entity, destination);
+            }
+            tx.commitIfActive();
+        }
+        finally {
+            if (ObjectUtils.isNotEmpty(tx)){
+                tx.rollbackIfActive();
+            }
+        }
+    }
+
+    private GetQuery<PartitionPropertyEntity> buildPartitionEntityQueryBy(Where where){
+        return new GetQuery<>(PartitionPropertyEntity.class, osmPartitionDestinationProvider.getDestination(), where);
+    }
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/security/AuthorizationService.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/security/AuthorizationService.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ebd163f82bff018ae5dd55af3492ba9d3aabbaa
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/security/AuthorizationService.java
@@ -0,0 +1,17 @@
+package org.opengroup.osdu.partition.coreplus.security;
+
+import lombok.extern.slf4j.Slf4j;
+import org.opengroup.osdu.partition.provider.interfaces.IAuthorizationService;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.annotation.RequestScope;
+
+@Slf4j
+@Component
+@RequestScope
+public class AuthorizationService implements IAuthorizationService {
+    @Override
+    public boolean isDomainAdminServiceAccount() {
+        //default implementation
+        return true;
+    }
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/security/SecurityConfig.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/security/SecurityConfig.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6f92bc7687af47a12cae122582472b6931de5a7
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/security/SecurityConfig.java
@@ -0,0 +1,27 @@
+package org.opengroup.osdu.partition.coreplus.security;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.builders.WebSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
+
+@EnableWebSecurity
+@Configuration
+@EnableGlobalMethodSecurity(prePostEnabled = true)
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+
+    @Override
+    protected void configure(HttpSecurity http) throws Exception {
+        http.httpBasic().disable()
+                .csrf().disable();
+    }
+
+    @Override
+    public void configure(WebSecurity web) throws Exception {
+        web.ignoring().antMatchers("/api-docs")
+                .antMatchers("/index")
+                .antMatchers("/swagger");
+    }
+}
diff --git a/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImpl.java b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..a819e10f41f86b2dcf75064f21b4eeb07c1fb654
--- /dev/null
+++ b/partition-core-plus/src/main/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImpl.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2020-2021 Google LLC
+ * Copyright 2020-2021 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.coreplus.service;
+
+import lombok.RequiredArgsConstructor;
+import org.apache.http.HttpStatus;
+import org.opengroup.osdu.core.common.cache.ICache;
+import org.opengroup.osdu.core.common.model.http.AppException;
+import org.opengroup.osdu.partition.logging.AuditLogger;
+import org.opengroup.osdu.partition.model.PartitionInfo;
+import org.opengroup.osdu.partition.model.Property;
+import org.opengroup.osdu.partition.coreplus.model.PartitionPropertyEntity;
+import org.opengroup.osdu.partition.coreplus.osm.repository.OsmPartitionPropertyRepository;
+import org.opengroup.osdu.partition.provider.interfaces.IPartitionService;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+
+import java.util.*;
+
+@Service
+@RequiredArgsConstructor
+public class PartitionServiceImpl implements IPartitionService {
+
+  static final String UNKNOWN_ERROR_REASON = "unknown error";
+  static final String PARTITION_LIST_KEY = "getAllPartitions";
+
+  private final OsmPartitionPropertyRepository partitionPropertyEntityRepository;
+
+  private final AuditLogger auditLogger;
+
+  private final ICache<String, PartitionInfo> partitionServiceCache;
+
+  private final ICache<String, List<String>> partitionListCache;
+
+  @Override
+  public PartitionInfo createPartition(String partitionId, PartitionInfo partitionInfo) {
+    if (partitionServiceCache.get(partitionId) != null)
+      throw new AppException(HttpStatus.SC_CONFLICT, "partition exist", "Partition with same id exist");
+
+    if (this.partitionPropertyEntityRepository.findByPartitionId(partitionId).isPresent()) {
+      this.auditLogger.createPartitionFailure(Collections.singletonList(partitionId));
+      throw new AppException(HttpStatus.SC_CONFLICT, UNKNOWN_ERROR_REASON,
+              "Partition already exists.");
+    }
+    List<PartitionPropertyEntity> partitionProperties = new ArrayList<>();
+    for (Map.Entry<String, Property> entry : partitionInfo.getProperties().entrySet()) {
+      PartitionPropertyEntity entity = new PartitionPropertyEntity(partitionId,
+              entry.getKey(), entry.getValue());
+      partitionProperties.add(entity);
+    }
+    this.partitionPropertyEntityRepository.saveAll(partitionProperties);
+    PartitionInfo pi = getPartition(partitionId);
+
+    if (Objects.nonNull(pi)) {
+      partitionListCache.clearAll();
+    }
+
+    return pi;
+  }
+
+  @Override
+  public PartitionInfo updatePartition(String partitionId, PartitionInfo partitionInfo) {
+    if (partitionInfo.getProperties().containsKey("id")) {
+      this.auditLogger.updatePartitionSecretFailure(Collections.singletonList(partitionId));
+      throw new AppException(HttpStatus.SC_BAD_REQUEST, "can not update id",
+              "the field id can not be updated");
+    }
+
+    if (!this.partitionPropertyEntityRepository.findByPartitionId(partitionId).isPresent()) {
+      this.auditLogger.updatePartitionSecretFailure(Collections.singletonList(partitionId));
+      throw new AppException(HttpStatus.SC_NOT_FOUND, UNKNOWN_ERROR_REASON,
+              "An attempt to update not existing partition.");
+    }
+
+    List<PartitionPropertyEntity> partitionProperties = new ArrayList<>();
+    for (Map.Entry<String, Property> entry : partitionInfo.getProperties().entrySet()) {
+      PartitionPropertyEntity entity = this.partitionPropertyEntityRepository
+              .findByPartitionIdAndName(partitionId, entry.getKey());
+      if (Objects.nonNull(entity)) {
+        entity.setSensitive(entry.getValue().isSensitive());
+        entity.setValue(entry.getValue().getValue());
+      } else {
+        entity = new PartitionPropertyEntity(partitionId, entry.getKey(), entry.getValue());
+      }
+      partitionProperties.add(entity);
+    }
+    this.partitionPropertyEntityRepository.saveAll(partitionProperties);
+    if (Objects.nonNull(partitionServiceCache.get(partitionId))) {
+      partitionServiceCache.delete(partitionId);
+    }
+
+    return getPartition(partitionId);
+  }
+
+  @Override
+  public PartitionInfo getPartition(String partitionId) {
+    PartitionInfo pi = partitionServiceCache.get(partitionId);
+
+    if (Objects.isNull(pi)) {
+      pi = getEncryptedPartition(partitionId);
+
+      if (Objects.nonNull(pi)) {
+        partitionServiceCache.put(partitionId, pi);
+      }
+    }
+
+    return pi;
+  }
+
+  private PartitionInfo getEncryptedPartition(String partitionId) {
+    Optional<List<PartitionPropertyEntity>> partitionPropertyEntitiesOptional = partitionPropertyEntityRepository
+            .findByPartitionId(partitionId);
+    if (!partitionPropertyEntitiesOptional.isPresent()) {
+      this.auditLogger.readPartitionFailure(Collections.singletonList(partitionId));
+      throw new AppException(HttpStatus.SC_NOT_FOUND, UNKNOWN_ERROR_REASON,
+          "Partition does not exist.");
+    }
+    List<PartitionPropertyEntity> partitionPropertiesList = partitionPropertyEntitiesOptional.get();
+    PartitionInfo partitionInfo = new PartitionInfo();
+    Map<String, Property> partitionInfoProperties = new HashMap<>();
+    for (PartitionPropertyEntity entity : partitionPropertiesList) {
+      partitionInfoProperties
+          .put(entity.getName(), new Property(entity.getSensitive(), entity.getValue()));
+    }
+    partitionInfo.setProperties(partitionInfoProperties);
+
+    return partitionInfo;
+  }
+
+  @Override
+  public boolean deletePartition(String partitionId) {
+    if (!this.partitionPropertyEntityRepository.findByPartitionId(partitionId).isPresent()) {
+      this.auditLogger.deletePartitionFailure(Collections.singletonList(partitionId));
+      throw new AppException(HttpStatus.SC_NOT_FOUND, UNKNOWN_ERROR_REASON,
+              "An attempt to delete not existing partition.");
+    }
+    this.partitionPropertyEntityRepository.deleteByPartitionId(partitionId);
+
+    if (Objects.nonNull(partitionServiceCache.get(partitionId))) {
+      partitionServiceCache.delete(partitionId);
+    }
+    partitionListCache.clearAll();
+    return true;
+  }
+
+  @Override
+  public List<String> getAllPartitions() {
+    List<String> partitions = partitionListCache.get(PARTITION_LIST_KEY);
+
+    if (Objects.isNull(partitions)) {
+      List<String> allPartitions = this.partitionPropertyEntityRepository.getAllPartitions();
+      partitions = (allPartitions.isEmpty() ? Collections.emptyList() : allPartitions);
+
+      if (!CollectionUtils.isEmpty(partitions)) {
+        partitionListCache.put(PARTITION_LIST_KEY, partitions);
+      }
+    }
+    return partitions;
+  }
+}
diff --git a/partition-core-plus/src/main/resources/application.properties b/partition-core-plus/src/main/resources/application.properties
new file mode 100644
index 0000000000000000000000000000000000000000..f784004aa9fec27919de326c280a4062544428e4
--- /dev/null
+++ b/partition-core-plus/src/main/resources/application.properties
@@ -0,0 +1,45 @@
+#
+# Copyright 2020-2022 Google LLC
+# Copyright 2020-2022 EPAM Systems, Inc
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#server config
+server.servlet.contextPath=/api/partition/v1
+server.port=8080
+springfox.documentation.swagger.v2.path=/api-docs
+management.endpoint.health.show-details=always
+management.health.diskspace.enabled=false
+ACCEPT_HTTP=true
+
+#logging configuration
+logging.level.org.springframework.web=${LOG_LEVEL:INFO}
+LOG_PREFIX=partition
+
+#cache config
+cache-expiration=1
+cache-maxSize=1000
+
+#service config
+partition-property-kind=PartitionProperty
+partition-namespace=partition
+
+osmDriver=postgres
+osm.postgres.url=${PARTITION_POSTGRES_URL}
+#Username and password to connect to the above url which contains the db name
+#Has to be in sync with the user created using the bootstrapping scripts
+osm.postgres.username=${PARTITION_POSTGRESQL_USERNAME:usr_partition_pg}
+osm.postgres.password=${PARTITION_POSTGRESQL_PASSWORD:partition_pg}
+#property used only for mandatory bean creation, not actually used in partition service
+dataPartitionId = ${DATA_PARTITION_ID:test-partition}
diff --git a/partition-core-plus/src/test/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImplCacheTest.java b/partition-core-plus/src/test/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImplCacheTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e85e83f83354ed8b39501d224c9a2e96771c3b3a
--- /dev/null
+++ b/partition-core-plus/src/test/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImplCacheTest.java
@@ -0,0 +1,191 @@
+/*
+  Copyright 2002-2021 Google LLC
+  Copyright 2002-2021 EPAM Systems, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.coreplus.service;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.opengroup.osdu.core.common.cache.ICache;
+import org.opengroup.osdu.core.common.model.http.AppException;
+import org.opengroup.osdu.partition.logging.AuditLogger;
+import org.opengroup.osdu.partition.model.PartitionInfo;
+import org.opengroup.osdu.partition.model.Property;
+import org.opengroup.osdu.partition.coreplus.model.PartitionPropertyEntity;
+import org.opengroup.osdu.partition.coreplus.osm.repository.OsmPartitionPropertyRepository;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class PartitionServiceImplCacheTest {
+
+    @Mock
+    private ICache<String, PartitionInfo> partitionServiceCache;
+
+    @Mock
+    private ICache<String, List<String>> partitionListCache;
+
+    @Mock
+    private OsmPartitionPropertyRepository partitionPropertyEntityRepository;
+
+    @Mock
+    private AuditLogger auditLogger;
+
+    private PartitionServiceImpl partitionServiceImpl;
+
+    @BeforeEach
+    public void setup() {
+        partitionServiceImpl = new PartitionServiceImpl(
+                partitionPropertyEntityRepository,
+                auditLogger,
+                partitionServiceCache,
+                partitionListCache
+        );
+    }
+
+    private List<PartitionPropertyEntity> partitionInfoToEntity(String partitionId, PartitionInfo partitionInfo) {
+        return partitionInfo.getProperties().entrySet().stream()
+                .map(entry -> new PartitionPropertyEntity(partitionId, entry.getKey(), entry.getValue()))
+                .collect(Collectors.toList());
+    }
+
+    @Test
+    public void createPartitionSucceed() {
+        String partId = "key";
+
+        PartitionInfo newPi = PartitionInfo.builder().build();
+        PartitionInfo retPi = PartitionInfo.builder().build();
+        String propKey = "123987123498";
+        retPi.getProperties().put(propKey, new Property());
+
+        doReturn(Optional.empty(), Optional.of(partitionInfoToEntity(partId, retPi)))
+                .when(partitionPropertyEntityRepository).findByPartitionId(partId);
+        partitionServiceImpl.createPartition(partId, newPi);
+
+        verify(partitionServiceCache, times(1))
+                .put(any(), argThat(argument -> argument.getProperties().containsKey(propKey)));
+        verify(partitionListCache).clearAll();
+    }
+
+        @Test
+        public void createPartitionFailed() {
+            String partId = "key";
+            PartitionInfo newPi = PartitionInfo.builder().build();
+
+            when(partitionServiceCache.get(partId)).thenReturn(null);
+            doReturn(Optional.empty())
+                    .when(partitionPropertyEntityRepository).findByPartitionId(partId);
+
+            assertThrows(AppException.class, () -> partitionServiceImpl.createPartition(partId, newPi));
+
+            verify(partitionServiceCache, times(0)).put(any(), any());
+            verify(partitionListCache, times(0)).clearAll();
+            verify(partitionServiceCache, times(2)).get(any());
+        }
+
+        @Test
+        public void updatePartitionSucceed() {
+            String partId = "key";
+
+            PartitionInfo newPi = PartitionInfo.builder().build();
+            PartitionInfo retPi = PartitionInfo.builder().build();
+            String propKey = "123987123498";
+            retPi.getProperties().put(propKey, new Property());
+
+            doReturn(Optional.of(partitionInfoToEntity(partId, retPi)))
+                    .when(partitionPropertyEntityRepository).findByPartitionId(partId);
+
+            partitionServiceImpl.updatePartition(partId, newPi);
+
+            verify(partitionServiceCache, times(1))
+                    .put(any(), argThat(argument -> argument.getProperties().containsKey(propKey)));
+        }
+
+        @Test
+        public void updatePartitionFailed() {
+            String partId = "key";
+            PartitionInfo newPi = PartitionInfo.builder().build();
+
+            doReturn(Optional.empty())
+                    .when(partitionPropertyEntityRepository).findByPartitionId(partId);
+
+            assertThrows(AppException.class, () -> partitionServiceImpl.updatePartition(partId, newPi));
+
+            verify(partitionServiceCache, times(0)).put(any(), any());
+            verify(partitionServiceCache, times(0)).get(any());
+        }
+
+
+        @Test
+        public void getPartition() {
+            String partId = "key";
+
+            PartitionInfo retPi = PartitionInfo.builder().build();
+            String propKey = "123987123498";
+            retPi.getProperties().put(propKey, new Property());
+
+            doReturn(Optional.of(partitionInfoToEntity(partId, retPi)))
+                    .when(partitionPropertyEntityRepository).findByPartitionId(partId);
+
+            partitionServiceImpl.getPartition(partId);
+
+            verify(partitionServiceCache, times(1)).get(partId);
+            verify(partitionPropertyEntityRepository, times(1)).findByPartitionId(partId);
+            verify(partitionServiceCache, times(1)).put(partId, retPi);
+        }
+
+        @Test
+        public void deletePartition() {
+            String partId = "key";
+            PartitionInfo retPi = PartitionInfo.builder().build();
+
+            doReturn(Optional.of(partitionInfoToEntity(partId, retPi)))
+                    .when(partitionPropertyEntityRepository).findByPartitionId(partId);
+            when(partitionServiceCache.get(partId)).thenReturn(retPi);
+
+            partitionServiceImpl.deletePartition(partId);
+
+            verify(partitionPropertyEntityRepository, times(1)).deleteByPartitionId(partId);
+            verify(partitionServiceCache, times(1)).delete(partId);
+            verify(partitionServiceCache, times(1)).get(partId);
+            verify(partitionListCache, times(1)).clearAll();
+        }
+
+        @Test
+        public void getAllPartitions() {
+            List<String> partitions = new ArrayList<>();
+            partitions.add("1");
+
+            doReturn(partitions)
+                    .when(partitionPropertyEntityRepository).getAllPartitions();
+
+            partitionServiceImpl.getAllPartitions();
+
+            verify(partitionListCache, times(1)).get(PartitionServiceImpl.PARTITION_LIST_KEY);
+            verify(partitionPropertyEntityRepository, times(1)).getAllPartitions();
+            verify(partitionListCache, times(1)).put(PartitionServiceImpl.PARTITION_LIST_KEY, partitions);
+        }
+}
diff --git a/partition-core-plus/src/test/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImplTest.java b/partition-core-plus/src/test/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImplTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0869047e70e81ea6d5adf1780e639434d656eebe
--- /dev/null
+++ b/partition-core-plus/src/test/java/org/opengroup/osdu/partition/coreplus/service/PartitionServiceImplTest.java
@@ -0,0 +1,190 @@
+/*
+  Copyright 2002-2021 Google LLC
+  Copyright 2002-2021 EPAM Systems, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.coreplus.service;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.opengroup.osdu.core.common.cache.ICache;
+import org.opengroup.osdu.core.common.model.http.AppException;
+import org.opengroup.osdu.partition.logging.AuditLogger;
+import org.opengroup.osdu.partition.model.PartitionInfo;
+import org.opengroup.osdu.partition.model.Property;
+import org.opengroup.osdu.partition.coreplus.model.PartitionPropertyEntity;
+import org.opengroup.osdu.partition.coreplus.osm.repository.OsmPartitionPropertyRepository;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class PartitionServiceImplTest {
+
+    private static final String PARTITION_ID = "newPartition";
+    private static final boolean SENSITIVE = false;
+    private static final String NAME = "new-key";
+    private static final String VALUE = "new-value";
+
+    @Mock
+    private ICache<String, PartitionInfo> partitionServiceCache;
+
+    @Mock
+    private ICache<String, List<String>> partitionListCache;
+
+    @Mock
+    private OsmPartitionPropertyRepository partitionPropertyEntityRepository;
+
+    @Mock
+    private AuditLogger auditLogger;
+
+    private PartitionServiceImpl partitionServiceImpl;
+
+    private PartitionInfo expectedPartitionInfo;
+    private PartitionPropertyEntity partitionPropertyEntity;
+    private Optional<List<PartitionPropertyEntity>> partitionPropertyEntityList;
+    private Optional<List<PartitionPropertyEntity>> emptyList;
+
+    @BeforeEach
+    public void setup() {
+        partitionServiceImpl = new PartitionServiceImpl(
+                partitionPropertyEntityRepository,
+                auditLogger,
+                partitionServiceCache,
+                partitionListCache
+        );
+
+        expectedPartitionInfo = new PartitionInfo();
+
+        Property property = new Property();
+        property.setSensitive(SENSITIVE);
+        property.setValue(VALUE);
+
+        Map<String, Property> properties = new HashMap<>();
+        properties.put(NAME, property);
+
+        expectedPartitionInfo.setProperties(properties);
+
+        partitionPropertyEntity = new PartitionPropertyEntity(PARTITION_ID, NAME, property);
+
+        List<PartitionPropertyEntity> entities = new ArrayList<>();
+        entities.add(partitionPropertyEntity);
+        partitionPropertyEntityList = Optional.of(entities);
+
+        emptyList = Optional.empty();
+    }
+
+    @Test
+    public void should_createPartition_when_partitionDoesNotExist() {
+        when(partitionPropertyEntityRepository.findByPartitionId(PARTITION_ID))
+                .thenReturn(emptyList, partitionPropertyEntityList);
+
+        PartitionInfo actualPartitionInfo = partitionServiceImpl
+                .createPartition(PARTITION_ID, expectedPartitionInfo);
+
+        assertEquals(expectedPartitionInfo, actualPartitionInfo);
+    }
+
+    @Test
+    public void should_throwAnException_when_createPartitionWhichAlreadyExists() {
+        assertThrows(AppException.class, () -> {
+            when(partitionPropertyEntityRepository.findByPartitionId(PARTITION_ID))
+                    .thenReturn(emptyList);
+
+            partitionServiceImpl.createPartition(PARTITION_ID, new PartitionInfo());
+        });
+    }
+
+    @Test
+    public void should_updatePartition_when_partitionExists() {
+        when(partitionPropertyEntityRepository.findByPartitionId(PARTITION_ID))
+                .thenReturn(partitionPropertyEntityList);
+        when(partitionPropertyEntityRepository.findByPartitionIdAndName(PARTITION_ID, NAME))
+                .thenReturn(null);
+
+        PartitionInfo actualPartitionInfo = partitionServiceImpl
+                .updatePartition(PARTITION_ID, expectedPartitionInfo);
+
+        assertEquals(expectedPartitionInfo, actualPartitionInfo);
+    }
+
+    @Test
+    public void should_throwAnException_when_updatePartitionWhichDoesNotExist() {
+        assertThrows(AppException.class, () -> {
+            when(partitionPropertyEntityRepository.findByPartitionId(PARTITION_ID))
+                    .thenReturn(emptyList);
+            partitionServiceImpl.createPartition(PARTITION_ID, new PartitionInfo());
+        });
+    }
+
+    @Test
+    public void should_getPartition_when_partitionExists() {
+        when(partitionPropertyEntityRepository.findByPartitionId(PARTITION_ID))
+                .thenReturn(partitionPropertyEntityList);
+
+        PartitionInfo actualPartitionInfo = partitionServiceImpl.getPartition(PARTITION_ID);
+
+        assertEquals(expectedPartitionInfo, actualPartitionInfo);
+    }
+
+    @Test
+    public void should_throwAnException_when_getPartitionWhichDoesNotExist() {
+        assertThrows(AppException.class, () -> {
+            when(partitionPropertyEntityRepository.findByPartitionId(PARTITION_ID))
+                    .thenReturn(emptyList);
+            partitionServiceImpl.getPartition(PARTITION_ID);
+        });
+    }
+
+    @Test
+    public void should_deletePartition_when_partitionExists() {
+        when(partitionPropertyEntityRepository.findByPartitionId(PARTITION_ID))
+                .thenReturn(partitionPropertyEntityList);
+        doNothing().when(partitionPropertyEntityRepository).deleteByPartitionId(PARTITION_ID);
+
+        boolean expected = true;
+        boolean actual = partitionServiceImpl.deletePartition(PARTITION_ID);
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    public void should_throwAnException_when_deletePartitionWhichDoesNotExist() {
+        assertThrows(AppException.class, () -> {
+            when(partitionPropertyEntityRepository.findByPartitionId(PARTITION_ID))
+                    .thenReturn(emptyList);
+            partitionServiceImpl.deletePartition(PARTITION_ID);
+        });
+    }
+
+    @Test
+    public void should_getAllPartitions() {
+        List<String> expectedPartitions = new ArrayList<>();
+        expectedPartitions.add(PARTITION_ID);
+
+        when(partitionPropertyEntityRepository.getAllPartitions()).thenReturn(expectedPartitions);
+
+        List<String> actualPartitions = partitionServiceImpl.getAllPartitions();
+
+        assertEquals(expectedPartitions, actualPartitions);
+    }
+}
diff --git a/pom.xml b/pom.xml
index 7d05cc56092ae67f9d20a3ea7217e76d6249d17c..61afda3a0bae00b1cdba13ed8327fda74738d250 100644
--- a/pom.xml
+++ b/pom.xml
@@ -141,6 +141,7 @@
     <module>provider/partition-aws</module>
     <module>provider/partition-ibm</module>
     <module>provider/partition-gc</module>
+      <module>partition-core-plus</module>
   </modules>
 
   <profiles>
diff --git a/testing/partition-test-core-plus/pom.xml b/testing/partition-test-core-plus/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f3dcee3e9288fdfb125019b268a5052dce7ef744
--- /dev/null
+++ b/testing/partition-test-core-plus/pom.xml
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Copyright 2020-2022 Google LLC
+  ~ Copyright 2020-2022 EPAM Systems, Inc
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~     https://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<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>
+
+    <parent>
+        <groupId>org.opengroup.osdu</groupId>
+        <artifactId>os-partition-testing</artifactId>
+        <version>0.24.0-SNAPSHOT</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+
+    <groupId>org.opengroup.osdu.partition</groupId>
+    <artifactId>partition-test-core-plus</artifactId>
+    <version>0.24.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <java.version>17</java.version>
+        <maven.compiler.target>17</maven.compiler.target>
+        <maven.compiler.source>17</maven.compiler.source>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.opengroup.osdu.partition</groupId>
+            <artifactId>partition-test-core</artifactId>
+            <version>0.24.0-SNAPSHOT</version>
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.opengroup.osdu</groupId>-->
+<!--            <artifactId>apd-openid</artifactId>-->
+<!--            <version>0.24.0-SNAPSHOT</version>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>com.nimbusds</groupId>
+            <artifactId>oauth2-oidc-sdk</artifactId>
+            <version>9.15</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.24</version>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>1.7.26</version>
+        </dependency>
+    </dependencies>
+</project>
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestCreatePartition.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestCreatePartition.java
new file mode 100644
index 0000000000000000000000000000000000000000..e45ce00b2e3e667db3ab3fd9de7442616c06ea42
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestCreatePartition.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.api;
+
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opengroup.osdu.partition.api.util.CorePlusAuthorizationTestUtil;
+import org.opengroup.osdu.partition.util.CorePlusTestUtils;
+
+import static org.junit.Assert.assertEquals;
+
+public class TestCreatePartition extends CreatePartitionTest {
+
+    private CorePlusAuthorizationTestUtil authorizationTestUtil;
+
+    @Override
+    @Before
+    public void setup() {
+        this.testUtils = new CorePlusTestUtils();
+        this.authorizationTestUtil = new CorePlusAuthorizationTestUtil(this.descriptor, this.testUtils);
+    }
+
+    @Override
+    @After
+    public void tearDown() throws Exception {
+        deleteResource();
+        this.testUtils = null;
+        this.authorizationTestUtil = null;
+    }
+
+    @Override
+    @Test
+    public void should_return40XResponseCode_when_makingRequest_withInvalidPayload()
+        throws Exception {
+        String invalidPayload = "{\"properties_invalid\":{}}";
+        CloseableHttpResponse response = descriptor.runWithCustomPayload(getId(), invalidPayload,
+            testUtils.getAccessToken());
+        assertEquals(400, response.getCode());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_noAccessToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_noAccessToken(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_accessingWithCredentialsWithoutPermission() throws Exception {
+        authorizationTestUtil.should_return401or403_when_accessingWithCredentialsWithoutPermission(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_makingHttpRequestWithoutToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_makingHttpRequestWithoutToken(getId());
+    }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestDeletePartition.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestDeletePartition.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a2de211e83a441ba3ae9cca0943878db66f5458
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestDeletePartition.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.api;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opengroup.osdu.partition.api.util.CorePlusAuthorizationTestUtil;
+import org.opengroup.osdu.partition.util.CorePlusTestUtils;
+
+public class TestDeletePartition extends DeletePartitionTest {
+
+    private CorePlusAuthorizationTestUtil authorizationTestUtil;
+
+    @Override
+    @Before
+    public void setup() {
+        this.testUtils = new CorePlusTestUtils();
+        this.authorizationTestUtil = new CorePlusAuthorizationTestUtil(this.descriptor, this.testUtils);
+    }
+
+    @Override
+    @After
+    public void tearDown() throws Exception {
+        deleteResource();
+        this.testUtils = null;
+        this.authorizationTestUtil = null;
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_noAccessToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_noAccessToken(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_accessingWithCredentialsWithoutPermission() throws Exception {
+        authorizationTestUtil.should_return401or403_when_accessingWithCredentialsWithoutPermission(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_makingHttpRequestWithoutToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_makingHttpRequestWithoutToken(getId());
+    }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestGetPartitionById.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestGetPartitionById.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5e084fae56bb44f2c991b3d980bc363e69f4269
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestGetPartitionById.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.api;
+
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opengroup.osdu.partition.api.descriptor.DeletePartitionDescriptor;
+import org.opengroup.osdu.partition.api.util.CorePlusAuthorizationTestUtil;
+import org.opengroup.osdu.partition.util.CorePlusTestUtils;
+
+public class TestGetPartitionById extends GetPartitionByIdApitTest {
+
+    private CorePlusAuthorizationTestUtil authorizationTestUtil;
+
+    @Override
+    @Before
+    public void setup() {
+        this.testUtils = new CorePlusTestUtils();
+        this.authorizationTestUtil = new CorePlusAuthorizationTestUtil(this.descriptor, this.testUtils);
+    }
+
+    @Override
+    @After
+    public void tearDown() throws Exception {
+        deleteResource();
+        this.testUtils = null;
+        this.authorizationTestUtil = null;
+    }
+
+    @Override
+    protected void deleteResource() throws Exception {
+        DeletePartitionDescriptor deletePartitionDes = new DeletePartitionDescriptor();
+        deletePartitionDes.setPartitionId(getId());
+        CloseableHttpResponse response = deletePartitionDes.run(getId(), this.testUtils.getAccessToken());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_noAccessToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_noAccessToken(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_accessingWithCredentialsWithoutPermission() throws Exception {
+        authorizationTestUtil.should_return401or403_when_accessingWithCredentialsWithoutPermission(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_makingHttpRequestWithoutToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_makingHttpRequestWithoutToken(getId());
+    }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestGetVersionInfo.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestGetVersionInfo.java
new file mode 100644
index 0000000000000000000000000000000000000000..99c97cd223fadb10c0594ea25462e91cdbdbe228
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestGetVersionInfo.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.api;
+
+import org.junit.After;
+import org.junit.Before;
+import org.opengroup.osdu.partition.util.CorePlusTestUtils;
+
+public class TestGetVersionInfo extends GetVersionInfoApiTest {
+
+    @Before
+    @Override
+    public void setup() {
+        this.testUtils = new CorePlusTestUtils();
+    }
+
+    @After
+    @Override
+    public void tearDown() {
+        this.testUtils = null;
+    }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestListPartitions.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestListPartitions.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7c369bc1d884dea26a01170b8382316480a528e
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestListPartitions.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.api;
+
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opengroup.osdu.partition.api.descriptor.DeletePartitionDescriptor;
+import org.opengroup.osdu.partition.api.util.CorePlusAuthorizationTestUtil;
+import org.opengroup.osdu.partition.util.CorePlusTestUtils;
+
+public class TestListPartitions extends ListPartitionsApitTest {
+
+    private CorePlusAuthorizationTestUtil authorizationTestUtil;
+
+    @Override
+    @Before
+    public void setup() {
+        this.testUtils = new CorePlusTestUtils();
+        this.authorizationTestUtil = new CorePlusAuthorizationTestUtil(this.descriptor, this.testUtils);
+    }
+
+    @Override
+    @After
+    public void tearDown() throws Exception {
+        deleteResource();
+        this.testUtils = null;
+        this.authorizationTestUtil = null;
+    }
+
+    @Override
+    protected void deleteResource() throws Exception {
+        DeletePartitionDescriptor deletePartitionDes = new DeletePartitionDescriptor();
+        deletePartitionDes.setPartitionId(getId());
+        CloseableHttpResponse response = deletePartitionDes.run(getId(), this.testUtils.getAccessToken());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_noAccessToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_noAccessToken(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_accessingWithCredentialsWithoutPermission() throws Exception {
+        authorizationTestUtil.should_return401or403_when_accessingWithCredentialsWithoutPermission(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_makingHttpRequestWithoutToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_makingHttpRequestWithoutToken(getId());
+    }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestUpdatePartition.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestUpdatePartition.java
new file mode 100644
index 0000000000000000000000000000000000000000..b0741d8aba2d3528be762fa5cbfe2acb1acaf444
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/TestUpdatePartition.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.api;
+
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opengroup.osdu.partition.api.descriptor.DeletePartitionDescriptor;
+import org.opengroup.osdu.partition.api.util.CorePlusAuthorizationTestUtil;
+import org.opengroup.osdu.partition.util.CorePlusTestUtils;
+
+public class TestUpdatePartition extends UpdatePartitionTest {
+
+    private CorePlusAuthorizationTestUtil authorizationTestUtil;
+
+    @Override
+    @Before
+    public void setup() {
+        this.testUtils = new CorePlusTestUtils();
+        this.authorizationTestUtil = new CorePlusAuthorizationTestUtil(this.descriptor, this.testUtils);
+    }
+
+    @Override
+    @After
+    public void tearDown() throws Exception {
+        deleteResource();
+        this.testUtils = null;
+        this.authorizationTestUtil = null;
+    }
+
+    @Override
+    protected void deleteResource() throws Exception {
+        DeletePartitionDescriptor deletePartitionDes = new DeletePartitionDescriptor();
+        deletePartitionDes.setPartitionId(getId());
+        CloseableHttpResponse response = deletePartitionDes.run(getId(), this.testUtils.getAccessToken());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_noAccessToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_noAccessToken(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_accessingWithCredentialsWithoutPermission() throws Exception {
+        authorizationTestUtil.should_return401or403_when_accessingWithCredentialsWithoutPermission(getId());
+    }
+
+    @Override
+    @Test
+    public void should_return401_when_makingHttpRequestWithoutToken() throws Exception {
+        authorizationTestUtil.should_return401or403_when_makingHttpRequestWithoutToken(getId());
+    }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/util/CorePlusAuthorizationTestUtil.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/util/CorePlusAuthorizationTestUtil.java
new file mode 100644
index 0000000000000000000000000000000000000000..7246f917c3e0e87fb19e9cf003c676c3cc290595
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/api/util/CorePlusAuthorizationTestUtil.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.api.util;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
+import org.opengroup.osdu.partition.util.RestDescriptor;
+import org.opengroup.osdu.partition.util.TestUtils;
+
+@Slf4j
+public class CorePlusAuthorizationTestUtil {
+
+  private RestDescriptor descriptor;
+  private TestUtils testUtils;
+
+  public CorePlusAuthorizationTestUtil(RestDescriptor descriptor, TestUtils testUtils) {
+    this.descriptor = descriptor;
+    this.testUtils = testUtils;
+  }
+
+  // Test depends on an infrastructure level.
+  public void should_return401or403_when_noAccessToken(String partitionId) throws Exception {
+    CloseableHttpResponse response = descriptor.runOnCustomerTenant(partitionId, testUtils.getNoAccessToken());
+    log.info(
+        "Test should_return401or403_when_noAccessToken has a response code = {}."
+            + "This test depends on an infrastructure level.",
+        response.getCode());
+  }
+
+  // Test depends on an infrastructure level.
+  public void should_return401or403_when_accessingWithCredentialsWithoutPermission(
+      String partitionId) throws Exception {
+    CloseableHttpResponse response = descriptor.run(partitionId, testUtils.getNoAccessToken());
+    log.info(
+        "Test should_return401or403_when_accessingWithCredentialsWithoutPermission has a response code = {}."
+            + "This test depends on an infrastructure level.",
+        response.getCode());
+  }
+
+  // Test depends on an infrastructure level.
+  public void should_return401or403_when_makingHttpRequestWithoutToken(String partitionId)
+      throws Exception {
+    CloseableHttpResponse response = descriptor.run(partitionId, "");
+    log.info(
+        "Test should_return401or403_when_makingHttpRequestWithoutToken has a response code = {}."
+            + "This test depends on an infrastructure level.",
+        response.getCode());
+  }
+
+  protected String error(String body) {
+    return String.format(
+        "%s: %s %s %s",
+        descriptor.getHttpMethod(), descriptor.getPath(), descriptor.getQuery(), body);
+  }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/CorePlusTestUtils.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/CorePlusTestUtils.java
new file mode 100644
index 0000000000000000000000000000000000000000..c09415d4f1a96c48b31b3091a997c3cb0d620be5
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/CorePlusTestUtils.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.util;
+
+public class CorePlusTestUtils extends TestUtils {
+
+    private final OpenIDTokenProvider tokenProvider = new OpenIDTokenProvider();
+
+    @Override
+    public String getAccessToken() {
+        return "Bearer " + tokenProvider.getToken();
+    }
+
+    @Override
+    public String getNoAccessToken() {
+        return "Bearer " + tokenProvider.getNoAccessToken();
+    }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/OpenIDTokenProvider.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/OpenIDTokenProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..57cf5542ef69aef180b0f8a91ac34afd84d4eaaf
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/OpenIDTokenProvider.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.util;
+
+import com.nimbusds.oauth2.sdk.AuthorizationGrant;
+import com.nimbusds.oauth2.sdk.ClientCredentialsGrant;
+import com.nimbusds.oauth2.sdk.ParseException;
+import com.nimbusds.oauth2.sdk.Scope;
+import com.nimbusds.oauth2.sdk.TokenRequest;
+import com.nimbusds.oauth2.sdk.TokenResponse;
+import com.nimbusds.oauth2.sdk.auth.ClientAuthentication;
+import com.nimbusds.oauth2.sdk.auth.ClientSecretBasic;
+import com.nimbusds.oauth2.sdk.auth.Secret;
+import com.nimbusds.oauth2.sdk.id.ClientID;
+import com.nimbusds.openid.connect.sdk.OIDCTokenResponseParser;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Objects;
+import net.minidev.json.JSONObject;
+import org.opengroup.osdu.partition.util.conf.OpenIDProviderConfig;
+
+public class OpenIDTokenProvider {
+
+    private static final OpenIDProviderConfig openIDProviderConfig = OpenIDProviderConfig.Instance();
+    private static final String ID_TOKEN = "id_token";
+    private final AuthorizationGrant clientGrant = new ClientCredentialsGrant();
+    private final URI tokenEndpointURI;
+    private final Scope scope;
+    private final ClientAuthentication clientAuthentication;
+    private final ClientAuthentication noAccessClientAuthentication;
+
+    public OpenIDTokenProvider() {
+        this.tokenEndpointURI = openIDProviderConfig.getProviderMetadata().getTokenEndpointURI();
+        this.scope = new Scope(openIDProviderConfig.getScopes());
+        this.clientAuthentication =
+            new ClientSecretBasic(
+                new ClientID(openIDProviderConfig.getClientId()),
+                new Secret(openIDProviderConfig.getClientSecret())
+            );
+        this.noAccessClientAuthentication =
+            new ClientSecretBasic(
+                new ClientID(openIDProviderConfig.getNoAccessClientId()),
+                new Secret(openIDProviderConfig.getNoAccessClientSecret())
+            );
+    }
+
+    public String getToken() {
+        try {
+            TokenRequest request = new TokenRequest(this.tokenEndpointURI, this.clientAuthentication, this.clientGrant, this.scope);
+            return requestToken(request);
+        } catch (ParseException | IOException e) {
+            throw new RuntimeException("Unable get credentials from INTEGRATION_TESTER variables", e);
+        }
+    }
+
+    public String getNoAccessToken() {
+        try {
+            TokenRequest request = new TokenRequest(this.tokenEndpointURI, this.noAccessClientAuthentication, this.clientGrant, this.scope);
+            return requestToken(request);
+        } catch (ParseException | IOException e) {
+            throw new RuntimeException("Unable get credentials from INTEGRATION_TESTER variables", e);
+        }
+    }
+
+    private String requestToken(TokenRequest tokenRequest) throws ParseException, IOException {
+
+        TokenResponse parse = OIDCTokenResponseParser.parse(tokenRequest.toHTTPRequest().send());
+
+        if (!parse.indicatesSuccess()) {
+            throw new RuntimeException("Unable get credentials from INTEGRATION_TESTER variables");
+        }
+
+        JSONObject jsonObject = parse.toSuccessResponse().toJSONObject();
+        String idTokenValue = jsonObject.getAsString(ID_TOKEN);
+        if (Objects.isNull(idTokenValue) || idTokenValue.isEmpty()) {
+            throw new RuntimeException("Unable get credentials from INTEGRATION_TESTER variables");
+        }
+        return idTokenValue;
+    }
+}
diff --git a/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/conf/OpenIDProviderConfig.java b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/conf/OpenIDProviderConfig.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c049c1fd8d592b1235ae005d92645f763e05689
--- /dev/null
+++ b/testing/partition-test-core-plus/src/test/java/org/opengroup/osdu/partition/util/conf/OpenIDProviderConfig.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2020-2022 Google LLC
+ * Copyright 2020-2022 EPAM Systems, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opengroup.osdu.partition.util.conf;
+
+import com.nimbusds.oauth2.sdk.http.HTTPRequest;
+import com.nimbusds.oauth2.sdk.http.HTTPResponse;
+import com.nimbusds.oauth2.sdk.id.Issuer;
+import com.nimbusds.openid.connect.sdk.op.OIDCProviderConfigurationRequest;
+import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata;
+
+public class OpenIDProviderConfig {
+
+    private String clientId;
+    private String clientSecret;
+    private String noAccessClientId;
+    private String noAccessClientSecret;
+    private String url;
+    private final String[] scopes = {"openid"};
+    private static final OpenIDProviderConfig openIDProviderConfig = new OpenIDProviderConfig();
+    private static OIDCProviderMetadata providerMetadata;
+
+    public static OpenIDProviderConfig Instance() {
+        try {
+            openIDProviderConfig.clientId = System.getProperty("TEST_OPENID_PROVIDER_CLIENT_ID", System.getenv("TEST_OPENID_PROVIDER_CLIENT_ID"));
+            openIDProviderConfig.clientSecret = System.getProperty("TEST_OPENID_PROVIDER_CLIENT_SECRET", System.getenv("TEST_OPENID_PROVIDER_CLIENT_SECRET"));
+            openIDProviderConfig.noAccessClientId =
+                System.getProperty("TEST_NO_ACCESS_OPENID_PROVIDER_CLIENT_ID", System.getenv("TEST_NO_ACCESS_OPENID_PROVIDER_CLIENT_ID"));
+            openIDProviderConfig.noAccessClientSecret =
+                System.getProperty("TEST_NO_ACCESS_OPENID_PROVIDER_CLIENT_SECRET", System.getenv("TEST_NO_ACCESS_OPENID_PROVIDER_CLIENT_SECRET"));
+            openIDProviderConfig.url = System.getProperty("TEST_OPENID_PROVIDER_URL", System.getenv("TEST_OPENID_PROVIDER_URL"));
+            Issuer issuer = new Issuer(openIDProviderConfig.url);
+            OIDCProviderConfigurationRequest request = new OIDCProviderConfigurationRequest(issuer);
+            HTTPRequest httpRequest = request.toHTTPRequest();
+            HTTPResponse httpResponse = httpRequest.send();
+            providerMetadata = OIDCProviderMetadata.parse(httpResponse.getContentAsJSONObject());
+        } catch (Exception e) {
+            throw new RuntimeException("Malformed token provider configuration", e);
+        }
+        return openIDProviderConfig;
+    }
+
+    public String getClientId() {
+        return clientId;
+    }
+
+    public String getClientSecret() {
+        return clientSecret;
+    }
+
+    public String getNoAccessClientId() {
+        return noAccessClientId;
+    }
+
+    public String getNoAccessClientSecret() {
+        return noAccessClientSecret;
+    }
+
+    public String[] getScopes() {
+        return scopes;
+    }
+
+    public OIDCProviderMetadata getProviderMetadata() {
+        return providerMetadata;
+    }
+}
diff --git a/testing/partition-test-core/src/main/java/org/opengroup/osdu/partition/util/TestUtils.java b/testing/partition-test-core/src/main/java/org/opengroup/osdu/partition/util/TestUtils.java
index 861b8a902ac7f730048fc59cd77e899097badf07..24f6a964329ab5470799164b852d811f897f53d4 100644
--- a/testing/partition-test-core/src/main/java/org/opengroup/osdu/partition/util/TestUtils.java
+++ b/testing/partition-test-core/src/main/java/org/opengroup/osdu/partition/util/TestUtils.java
@@ -25,6 +25,7 @@ import org.apache.hc.core5.http.ClassicHttpRequest;
 import org.apache.hc.core5.http.ContentType;
 import org.apache.hc.core5.http.io.support.ClassicRequestBuilder;
 
+import java.io.Console;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -96,6 +97,7 @@ public abstract class TestUtils {
 	private static ClassicHttpRequest createHttpRequest(String path, String httpMethod, String token, String requestBody,
 														Map<String, String> headers, boolean enforceHttp) throws MalformedURLException {
 		String url = getApiPath(path, enforceHttp);
+		System.out.print("http req: " + url);
 		ClassicRequestBuilder classicRequestBuilder = ClassicRequestBuilder.create(httpMethod)
 				.setUri(url)
 				.addHeader("Authorization", token)
@@ -106,6 +108,7 @@ public abstract class TestUtils {
 
 	private static ClassicHttpRequest createHttpRequest(String path, String httpMethod, boolean enforceHttp) throws MalformedURLException {
 		String url = getApiPath(path, enforceHttp);
+		System.out.print("http req: " + url);
 		return ClassicRequestBuilder.create(httpMethod).setUri(url).build();
 	}
 
diff --git a/testing/pom.xml b/testing/pom.xml
index 3a2f480f3557a2061ac76570102bc101f88c5fa9..d726c825aacb75bba0800f8efa37c3e2248741ba 100644
--- a/testing/pom.xml
+++ b/testing/pom.xml
@@ -36,6 +36,7 @@
 		<module>partition-test-ibm</module>
     	<module>partition-test-gc</module>
 		<module>partition-test-baremetal</module>
+		<module>partition-test-core-plus</module>
   </modules>
 
 	<repositories>