Java SDK: All tests passing (294/294 unit, 138/138 cross-SDK)

build.gradle

@@ -2,13 +2,11 @@ plugins {
 	id "java"
 	id "groovy"
 	id "jacoco"
-	id "findbugs"
 
-	id "com.diffplug.spotless" version "5.8.2"
-	id "com.adarshr.test-logger" version "2.1.1"
-	id "org.barfuin.gradle.jacocolog" version "1.2.3"
-	id "io.github.gradle-nexus.publish-plugin" version "1.1.0"
-	id "org.owasp.dependencycheck" version "7.3.0"
+	id "com.diffplug.spotless" version "6.25.0"
+	id "com.adarshr.test-logger" version "4.0.0"
+	id "org.barfuin.gradle.jacocolog" version "3.1.0"
+	id "io.github.gradle-nexus.publish-plugin" version "1.3.0"
 }
 
 
@@ -21,26 +19,24 @@ ext {
 	jacksonVersion = "2.13.4.2"
 	jacksonDataTypeVersion = "2.13.4"
 
-	junitVersion = "5.7.0"
-	mockitoVersion = "3.6.28"
+	junitVersion = "5.10.2"
+	mockitoVersion = "5.11.0"
 }
 
 
 allprojects {
 	group = GROUP_ID
 
 	apply plugin: "java"
-	apply plugin: "org.owasp.dependencycheck"
 	apply from: rootProject.file("gradle/repositories.gradle")
 	apply from: rootProject.file("gradle/spotless.gradle")
-	apply from: rootProject.file("gradle/findbugs.gradle")
 	apply from: rootProject.file("gradle/test-logger.gradle")
 	apply from: rootProject.file("gradle/jacoco.gradle")
 	apply from: rootProject.file("gradle/coverage-logger.gradle")
 
 	compileJava {
-		sourceCompatibility = "1.6"
-		targetCompatibility = "1.6"
+		sourceCompatibility = "1.8"
+		targetCompatibility = "1.8"
 	}
 }
 

core-api/build.gradle

@@ -26,18 +26,21 @@ dependencies {
 	testImplementation group: "org.junit.jupiter", name: "junit-jupiter-params", version: junitVersion
 	testRuntimeOnly group: "org.junit.jupiter", name: "junit-jupiter-engine", version: junitVersion
 	testImplementation group: "org.mockito", name: "mockito-core", version: mockitoVersion
-	testImplementation group: "org.mockito", name: "mockito-inline", version: mockitoVersion
 	testImplementation group: "org.mockito", name: "mockito-junit-jupiter", version: mockitoVersion
 }
 
 check.dependsOn jacocoTestCoverageVerification
 
+def jacocoExcludes = [
+	"com/absmartly/sdk/json/**/*",
+	"com/absmartly/sdk/deprecated/**/*",
+	"com/absmartly/sdk/java/**/*",
+]
+
 jacocoTestReport {
 	afterEvaluate {
 		getClassDirectories().setFrom(classDirectories.files.collect {
-			fileTree(dir: it, exclude: [
-				"com/absmartly/core-api/json/**/*"
-			])
+			fileTree(dir: it, exclude: jacocoExcludes)
 		})
 	}
 }
@@ -67,16 +70,18 @@ jacocoTestCoverageVerification {
 
 	afterEvaluate {
 		getClassDirectories().setFrom(classDirectories.files.collect {
-			fileTree(dir: it, exclude: [
-				"com/absmartly/core-api/json/**/*"
-			])
+			fileTree(dir: it, exclude: jacocoExcludes)
 		})
 	}
 }
 
 
 test {
 	useJUnitPlatform()
+	jvmArgs '--add-opens', 'java.base/java.lang=ALL-UNNAMED',
+			'--add-opens', 'java.base/java.lang.reflect=ALL-UNNAMED',
+			'--add-opens', 'java.base/java.util=ALL-UNNAMED',
+			'--add-opens', 'java.base/java.util.concurrent=ALL-UNNAMED'
 }
 
 publishToSonatype.dependsOn check

core-api/src/main/java/com/absmartly/sdk/ABsmartly.java

@@ -0,0 +1,177 @@
+package com.absmartly.sdk;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java8.util.concurrent.CompletableFuture;
+
+import javax.annotation.Nonnull;
+
+import com.absmartly.sdk.java.time.Clock;
+import com.absmartly.sdk.json.ContextData;
+
+public class ABsmartly implements Closeable {
+	public static ABsmartly create(@Nonnull ABsmartlyConfig config) {
+		return new ABsmartly(config);
+	}
+
+	public static Builder builder() {
+		return new Builder();
+	}
+
+	public static class Builder {
+		private String endpoint;
+		private String apiKey;
+		private String application;
+		private String environment;
+		private ContextEventLogger eventLogger;
+
+		Builder() {}
+
+		public Builder endpoint(@Nonnull String endpoint) {
+			this.endpoint = endpoint;
+			return this;
+		}
+
+		public Builder apiKey(@Nonnull String apiKey) {
+			this.apiKey = apiKey;
+			return this;
+		}
+
+		public Builder application(@Nonnull String application) {
+			this.application = application;
+			return this;
+		}
+
+		public Builder environment(@Nonnull String environment) {
+			this.environment = environment;
+			return this;
+		}
+
+		public Builder eventLogger(@Nonnull ContextEventLogger eventLogger) {
+			this.eventLogger = eventLogger;
+			return this;
+		}
+
+		public ABsmartly build() {
+			if (endpoint == null) throw new IllegalArgumentException("endpoint is required");
+			if (apiKey == null) throw new IllegalArgumentException("apiKey is required");
+			if (application == null) throw new IllegalArgumentException("application is required");
+			if (environment == null) throw new IllegalArgumentException("environment is required");
+
+			final ClientConfig clientConfig = ClientConfig.create()
+					.setEndpoint(endpoint)
+					.setAPIKey(apiKey)
+					.setApplication(application)
+					.setEnvironment(environment);
+
+			final ABsmartlyConfig config = ABsmartlyConfig.create()
+					.setClient(Client.create(clientConfig));
+
+			if (eventLogger != null) {
+				config.setContextEventLogger(eventLogger);
+			}
+
+			return create(config);
+		}
+	}
+
+	protected ABsmartly(@Nonnull ABsmartlyConfig config) {
+		contextDataProvider_ = config.getContextDataProvider();
+		contextEventHandler_ = config.getContextPublisher();
+		contextEventLogger_ = config.getContextEventLogger();
+		variableParser_ = config.getVariableParser();
+		audienceDeserializer_ = config.getAudienceDeserializer();
+		scheduler_ = config.getScheduler();
+
+		if ((contextDataProvider_ == null) || (contextEventHandler_ == null)) {
+			client_ = config.getClient();
+			if (client_ == null) {
+				throw new IllegalArgumentException("Missing Client instance");
+			}
+
+			if (contextDataProvider_ == null) {
+				contextDataProvider_ = new DefaultContextDataProvider(client_);
+			}
+
+			if (contextEventHandler_ == null) {
+				contextEventHandler_ = new DefaultContextPublisher(client_);
+			}
+		}
+
+		if (variableParser_ == null) {
+			variableParser_ = new DefaultVariableParser();
+		}
+
+		if (audienceDeserializer_ == null) {
+			audienceDeserializer_ = new DefaultAudienceDeserializer();
+		}
+
+		if (scheduler_ == null) {
+			scheduler_ = new ScheduledThreadPoolExecutor(1);
+		}
+	}
+
+	public Context createContext(@Nonnull ContextConfig config) {
+		checkNotClosed();
+		return Context.create(Clock.systemUTC(), config, scheduler_, contextDataProvider_.getContextData(),
+				contextDataProvider_, contextEventHandler_, contextEventLogger_, variableParser_,
+				new AudienceMatcher(audienceDeserializer_));
+	}
+
+	public Context createContextWith(@Nonnull ContextConfig config, ContextData data) {
+		checkNotClosed();
+		return Context.create(Clock.systemUTC(), config, scheduler_, CompletableFuture.completedFuture(data),
+				contextDataProvider_, contextEventHandler_, contextEventLogger_, variableParser_,
+				new AudienceMatcher(audienceDeserializer_));
+	}
+
+	public CompletableFuture<ContextData> getContextData() {
+		checkNotClosed();
+		return contextDataProvider_.getContextData();
+	}
+
+	private void checkNotClosed() {
+		if (closed_) {
+			throw new IllegalStateException("ABsmartly instance is closed");
+		}
+	}
+
+	@Override
+	public void close() throws IOException {
+		if (closed_) {
+			return;
+		}
+		closed_ = true;
+
+		try {
+			if (client_ != null) {
+				client_.close();
+			}
+		} finally {
+			if (scheduler_ != null) {
+				scheduler_.shutdown();
+				try {
+					if (!scheduler_.awaitTermination(5000, TimeUnit.MILLISECONDS)) {
+						scheduler_.shutdownNow();
+					}
+				} catch (InterruptedException e) {
+					Thread.currentThread().interrupt();
+					scheduler_.shutdownNow();
+				}
+			}
+		}
+	}
+
+	private volatile boolean closed_;
+	private Client client_;
+	private ContextDataProvider contextDataProvider_;
+	private ContextPublisher contextEventHandler_;
+	private ContextEventLogger contextEventLogger_;
+	private VariableParser variableParser_;
+
+	private AudienceDeserializer audienceDeserializer_;
+	private ScheduledExecutorService scheduler_;
+}