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

.github/workflows/main.yml

@@ -12,11 +12,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Setup Java 8
+      - name: Setup Java 11
         uses: actions/setup-java@v3
         with:
           distribution: "adopt"
-          java-version: "8"
+          java-version: "11"
           cache: "gradle"
 
       - name: Build Java SDK

.github/workflows/publish.yml

@@ -11,11 +11,11 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Setup Java 8
+      - name: Setup Java 11
         uses: actions/setup-java@v3
         with:
           distribution: "adopt"
-          java-version: "8"
+          java-version: "11"
           cache: "gradle"
 
       - name: Publish JavaSDK

.gitignore

@@ -11,3 +11,4 @@
 *.log
 build/
 out/
+.claude/

build.gradle

@@ -2,13 +2,12 @@ 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"
+	id "ru.vyarus.animalsniffer" version "1.7.1" apply false
 }
 
 
@@ -21,22 +20,21 @@ 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")
+	apply from: rootProject.file("gradle/compatibility.gradle")
 
 	compileJava {
 		sourceCompatibility = "1.6"

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

@@ -17,13 +17,79 @@ 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);
+		}
+	}
+
 	private ABSmartly(@Nonnull ABSmartlyConfig config) {
 		contextDataProvider_ = config.getContextDataProvider();
 		contextEventHandler_ = config.getContextEventHandler();
 		contextEventLogger_ = config.getContextEventLogger();
 		variableParser_ = config.getVariableParser();
 		audienceDeserializer_ = config.getAudienceDeserializer();
 		scheduler_ = config.getScheduler();
+		ownsScheduler_ = scheduler_ == null;
 
 		if ((contextDataProvider_ == null) || (contextEventHandler_ == null)) {
 			client_ = config.getClient();
@@ -54,36 +120,58 @@ private ABSmartly(@Nonnull ABSmartlyConfig config) {
 	}
 
 	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 (client_ != null) {
-			client_.close();
-			client_ = null;
+		if (closed_) {
+			return;
 		}
+		closed_ = true;
 
-		if (scheduler_ != null) {
-			try {
-				scheduler_.awaitTermination(5000, TimeUnit.MILLISECONDS);
-			} catch (InterruptedException ignored) {}
-			scheduler_ = null;
+		try {
+			if (client_ != null) {
+				client_.close();
+			}
+		} finally {
+			// A caller-supplied scheduler remains under caller ownership and must be left running.
+			if ((scheduler_ != null) && ownsScheduler_) {
+				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 ContextEventHandler contextEventHandler_;
@@ -92,4 +180,5 @@ public void close() throws IOException {
 
 	private AudienceDeserializer audienceDeserializer_;
 	private ScheduledExecutorService scheduler_;
+	private final boolean ownsScheduler_;
 }

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

@@ -25,6 +25,9 @@ public boolean get() {
 	}
 
 	public Result evaluate(String audience, Map<String, Object> attributes) {
+		if (audience == null || audience.isEmpty()) {
+			return null;
+		}
 		final byte[] bytes = audience.getBytes(StandardCharsets.UTF_8);
 		final Map<String, Object> audienceMap = deserializer_.deserialize(bytes, 0, bytes.length);
 		if (audienceMap != null) {

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

@@ -13,10 +13,15 @@
 
 import javax.annotation.Nonnull;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import com.absmartly.sdk.json.ContextData;
 import com.absmartly.sdk.json.PublishEvent;
 
 public class Client implements Closeable {
+	private static final Logger log = LoggerFactory.getLogger(Client.class);
+
 	static public Client create(@Nonnull final ClientConfig config) {
 		return new Client(config, DefaultHTTPClient.create(DefaultHTTPClientConfig.create()));
 	}
@@ -31,6 +36,15 @@ static public Client create(@Nonnull final ClientConfig config, @Nonnull final H
 			throw new IllegalArgumentException("Missing Endpoint configuration");
 		}
 
+		if (!endpoint.startsWith("https://")) {
+			if (endpoint.startsWith("http://")) {
+				log.warn("ABSmartly SDK endpoint is not using HTTPS. API keys will be transmitted in plaintext: {}",
+						endpoint);
+			} else {
+				throw new IllegalArgumentException("Endpoint must use http:// or https:// protocol: " + endpoint);
+			}
+		}
+
 		final String apiKey = config.getAPIKey();
 		if ((apiKey == null) || apiKey.isEmpty()) {
 			throw new IllegalArgumentException("Missing APIKey configuration");
@@ -46,7 +60,9 @@ static public Client create(@Nonnull final ClientConfig config, @Nonnull final H
 			throw new IllegalArgumentException("Missing Environment configuration");
 		}
 
-		url_ = endpoint + "/context";
+		final String normalizedEndpoint = endpoint.endsWith("/") ? endpoint.substring(0, endpoint.length() - 1)
+				: endpoint;
+		url_ = normalizedEndpoint + "/context";
 		httpClient_ = httpClient;
 		deserializer_ = config.getContextDataDeserializer();
 		serializer_ = config.getContextEventSerializer();
@@ -86,8 +102,19 @@ public void accept(HTTPClient.Response response) {
 								final int code = response.getStatusCode();
 								if ((code / 100) == 2) {
 									final byte[] content = response.getContent();
-									dataFuture.complete(
-											deserializer_.deserialize(response.getContent(), 0, content.length));
+									if (content == null || content.length == 0) {
+										dataFuture.completeExceptionally(new IllegalStateException(
+												"Empty response body from context data endpoint"));
+									} else {
+										final ContextData result = deserializer_.deserialize(content, 0,
+												content.length);
+										if (result != null) {
+											dataFuture.complete(result);
+										} else {
+											dataFuture.completeExceptionally(new IllegalStateException(
+													"Failed to deserialize context data response"));
+										}
+									}
 								} else {
 									dataFuture.completeExceptionally(new Exception(response.getStatusMessage()));
 								}