Adding tests and gh actions to build and package

ASRagab · ASRagab · commit 7d1e564f49c2 · 2024-12-24T19:25:34.000-05:00
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -0,0 +1,43 @@
+name: Test and submit dependencies
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: "17"
+          distribution: "temurin"
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Run tests
+        run: ./gradlew test
+
+  dependency-submission:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: "17"
+          distribution: "temurin"
+
+      - name: Generate and submit dependency graph
+        uses: gradle/actions/dependency-submission@v4
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
@@ -0,0 +1,33 @@
+name: Package and publish
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: "17"
+          distribution: "temurin"
+          server-id: github
+          settings-path: ${{ github.workspace }} # location for the settings.xml file
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@af1da67850ed9a4cedd57bfd976089dd991e2582 # v4.0.0
+
+      - name: Build with Gradle
+        run: ./gradlew s2:build
+
+      - name: Publish to GitHub Packages
+        run: ./gradlew s2:publish
+        env:
+          GH_ACTOR: ${{ github.actor }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -2,7 +2,7 @@
 # https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format
 
 [versions]
-junit-jupiter = "5.9.2"
+junit-jupiter = "5.11.4"
 
 [libraries]
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
diff --git a/s2/build.gradle.kts b/s2/build.gradle.kts
@@ -12,6 +12,8 @@ val grpcVersion = "1.64.0"
 val protobufVersion = "3.25.0"
 val tomcatAnnotationsVersion = "11.0.2"
 val javaxAnnotationVersion = "1.3.2"
+val mockitoVersion = "5.8.0"
+val assertJVersion = "3.24.2"
 
 dependencies {
     implementation("io.grpc:grpc-protobuf:$grpcVersion")
@@ -24,10 +26,17 @@ dependencies {
     
     compileOnly("org.apache.tomcat:tomcat-annotations-api:$tomcatAnnotationsVersion")
 
-
-    
+    testImplementation(platform("org.junit:junit-bom:5.11.4"))
     testImplementation(libs.junit.jupiter)
     testImplementation("io.grpc:grpc-testing:$grpcVersion")
+    testImplementation("io.grpc:grpc-inprocess:$grpcVersion")
+    testImplementation("org.mockito:mockito-core:$mockitoVersion")
+    testImplementation("org.mockito:mockito-junit-jupiter:$mockitoVersion") {
+        exclude(group = "org.junit.jupiter")
+    }
+    testImplementation("org.assertj:assertj-core:$assertJVersion")
+    
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 protobuf {
@@ -54,6 +63,9 @@ tasks.withType<JavaCompile>().configureEach {
 
 tasks.test {
     useJUnitPlatform()
+    testLogging {
+      events("passed", "skipped", "failed")
+    }
 }
 
 java {
@@ -70,5 +82,15 @@ publishing {
       version = "0.0.1"
       from(components["java"])
     }
+    repositories {
+        maven {
+            name = "GitHubPackages"
+            url = uri("https://maven.pkg.github.com/twelvehart/s2-java-sdk")
+            credentials {
+                username = System.getenv("GH_ACTOR")
+                password = System.getenv("GH_TOKEN")
+            }
+        }
+    }
   }
 }
diff --git a/s2/src/test/java/s2/auth/BearerTokenCallCredentialsTest.java b/s2/src/test/java/s2/auth/BearerTokenCallCredentialsTest.java
@@ -0,0 +1,54 @@
+package s2.auth;
+
+import io.grpc.CallCredentials;
+import io.grpc.Metadata;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.concurrent.Executor;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.Mockito.verify;
+
+@ExtendWith(MockitoExtension.class)
+class BearerTokenCallCredentialsTest {
+
+  @Mock
+  private CallCredentials.MetadataApplier metadataApplier;
+
+  @Test
+  void shouldAddBearerTokenToMetadata() {
+    var token = "test-token";
+    var credentials = new BearerTokenCallCredentials(token);
+    Executor directExecutor = Runnable::run;
+
+    credentials.applyRequestMetadata(null, directExecutor, metadataApplier);
+
+    var metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
+    verify(metadataApplier).apply(metadataCaptor.capture());
+
+    var capturedMetadata = metadataCaptor.getValue();
+    var authHeader =
+        capturedMetadata.get(Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER));
+
+    assertThat(authHeader).isNotNull().isEqualTo("Bearer " + token);
+  }
+
+  @Test
+  void shouldRejectNullToken() {
+    assertThatThrownBy(() -> new BearerTokenCallCredentials(null))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Token cannot be null or empty");
+  }
+
+  @Test
+  void shouldRejectEmptyToken() {
+    assertThatThrownBy(() -> new BearerTokenCallCredentials("  "))
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Token cannot be null or empty");
+  }
+}
diff --git a/s2/src/test/java/s2/channel/ChannelManagerTest.java b/s2/src/test/java/s2/channel/ChannelManagerTest.java
@@ -0,0 +1,71 @@
+package s2.channel;
+
+import org.junit.jupiter.api.Test;
+import java.util.concurrent.TimeUnit;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ChannelManagerTest {
+
+  @Test
+  void shouldCreateAndManageChannelsCorrectly() {
+    var host = "localhost";
+    var port = 50051;
+    var useTls = false;
+    try (var channelManager = new ChannelManager(host, port, useTls)) {
+      var channel1 = channelManager.createChannel();
+      var currentChannel = channelManager.getCurrentChannel();
+
+      // Then initial channel should be set
+      assertThat(channel1).isNotNull();
+      assertThat(currentChannel).isPresent();
+      assertThat(currentChannel.get()).isSameAs(channel1);
+
+      // When switching to a basin
+      var basinChannel = channelManager.switchToBasin("test-basin");
+      var updatedChannel = channelManager.getCurrentChannel();
+
+      // Then basin channel should be current and different from initial channel
+      assertThat(basinChannel).isNotNull();
+      assertThat(updatedChannel).isPresent();
+      assertThat(updatedChannel.get()).isSameAs(basinChannel);
+      assertThat(updatedChannel.get()).isNotSameAs(channel1);
+
+      // Assert both channels are not shutdown until explicitly closed
+      assertThat(channel1.isShutdown()).isFalse();
+      assertThat(basinChannel.isShutdown()).isFalse();
+    }
+  }
+
+  @Test
+  void shouldHandleChannelShutdownGracefully() throws InterruptedException {
+    // Given
+    var host = "localhost";
+    var port = 50052;
+    var useTls = false;
+
+    var channelManager = new ChannelManager(host, port, useTls);
+
+    // When
+    var channel = channelManager.createChannel();
+    channelManager.close();
+
+    // Then
+    assertThat(channel.isShutdown()).isTrue();
+    assertThat(channel.awaitTermination(5, TimeUnit.SECONDS)).isTrue();
+  }
+
+  @Test
+  void shouldCreateBasinChannelWithCorrectHost() {
+    var host = "example.com";
+    var port = 50053;
+    var useTls = false;
+    var basinName = "test-basin";
+
+    try (var channelManager = new ChannelManager(host, port, useTls)) {
+      var basinChannel = channelManager.createBasinChannel(basinName);
+
+      assertThat(basinChannel).isNotNull();
+      assertThat(basinChannel.isShutdown()).isFalse();
+    }
+  }
+}
diff --git a/s2/src/test/java/s2/services/ClientBuilderTest.java b/s2/src/test/java/s2/services/ClientBuilderTest.java
@@ -0,0 +1,93 @@
+package s2.services;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import io.grpc.ManagedChannel;
+import io.grpc.CallCredentials;
+import s2.auth.BearerTokenCallCredentials;
+
+@ExtendWith(MockitoExtension.class)
+public class ClientBuilderTest {
+  @Mock
+  private ManagedChannel mockChannel;
+
+  private static final String TEST_HOST = "test.s2.dev";
+  private static final String TEST_TOKEN = "test-token";
+  private static final String TEST_BASIN = "test-basin";
+
+  @Test
+  void builderShouldCreateClientWithMinimalParameters() {
+    Client client = Client.newBuilder().host(TEST_HOST).bearerToken(TEST_TOKEN).build();
+
+    assertNotNull(client);
+    assertNotNull(client.account());
+    assertNotNull(client.basin());
+    assertNotNull(client.stream());
+    assertNotNull(client.streamAsync());
+  }
+
+  @Test
+  void builderShouldCreateClientWithInjectedChannel() {
+    CallCredentials credentials = new BearerTokenCallCredentials(TEST_TOKEN);
+    Client client = Client.newBuilder().channel(mockChannel).credentials(credentials).build();
+
+    assertNotNull(client);
+  }
+
+  @Test
+  void builderShouldThrowWhenMissingRequiredParameters() {
+    ClientBuilder builder = Client.newBuilder();
+
+    assertThrows(IllegalStateException.class, builder::build,
+        "Should throw when no parameters are set");
+
+    assertThrows(IllegalStateException.class, () -> builder.host(TEST_HOST).build(),
+        "Should throw when bearer token is missing");
+
+    ClientBuilder tokenBuilder = Client.newBuilder();
+    assertThrows(IllegalStateException.class, () -> tokenBuilder.bearerToken(TEST_TOKEN).build(),
+        "Should throw when host is missing");
+  }
+
+  @Test
+  void useBasinShouldThrowWithInjectedChannel() {
+    CallCredentials credentials = new BearerTokenCallCredentials(TEST_TOKEN);
+    Client client = Client.newBuilder().channel(mockChannel).credentials(credentials).build();
+
+    assertThrows(UnsupportedOperationException.class, () -> client.useBasin(TEST_BASIN),
+        "Should throw when using injected channel");
+  }
+
+  @Test
+  void useBasinShouldWorkWithManagedChannel() {
+    Client client = Client.newBuilder().host(TEST_HOST).bearerToken(TEST_TOKEN).build();
+
+    // This should not throw
+    assertDoesNotThrow(() -> client.useBasin(TEST_BASIN));
+  }
+
+  @Test
+  void closeShouldWorkWithManagedChannel() {
+    Client client = Client.newBuilder().host(TEST_HOST).bearerToken(TEST_TOKEN).build();
+
+    // This should not throw
+    assertDoesNotThrow(client::close);
+  }
+
+  @Test
+  void closeShouldNotAffectInjectedChannel() {
+    CallCredentials credentials = new BearerTokenCallCredentials(TEST_TOKEN);
+    Client client = Client.newBuilder().channel(mockChannel).credentials(credentials).build();
+
+    client.close();
+
+    // Verify channel was not shut down
+    verify(mockChannel, never()).shutdown();
+  }
+}
diff --git a/s2/src/test/java/s2/services/ClientTest.java b/s2/src/test/java/s2/services/ClientTest.java
