chore: change contructor to builder class

Author: github-actions

src/main/java/io/getstream/client/AuditLogsClient.java

@@ -52,8 +52,6 @@ public CompletableFuture<QueryAuditLogsResponse> queryAuditLogs(QueryAuditLogsFi
             throw new StreamException("Filters cannot be null for audit logs queries");
         }
 
-        filters.validate();
-        
         final Token token = buildAuditLogsToken(secret, TokenAction.READ);
 
         RequestOption[] options = buildRequestOptions(filters, pager);

src/main/java/io/getstream/client/QueryAuditLogsFilters.java

@@ -5,6 +5,12 @@
 /**
  * Filters for querying audit logs.
  * Either entityType+entityID pair OR userID is required by the API.
+ * 
+ * Common entity types in Stream include:
+ * - "activity" - for feed activities
+ * - "reaction" - for activity reactions
+ * - "user" - for Stream users
+ * - "feed" - for feed configurations
  */
 public class QueryAuditLogsFilters {
     private String entityType;
@@ -39,14 +45,34 @@ public static QueryAuditLogsFilters forUser(String userID) {
     /**
      * Creates a new filter for entity type and ID queries.
      * 
-     * @param entityType The type of entity (e.g., "user", "feed")
+     * @param entityType The type of entity (e.g., "activity", "reaction", "user", "feed")
      * @param entityID The ID of the entity
      * @return a new QueryAuditLogsFilters with the entity type and ID set
      */
     public static QueryAuditLogsFilters forEntity(String entityType, String entityID) {
         return builder().withEntityType(entityType).withEntityID(entityID).build();
     }
 
+    /**
+     * Convenience method to create a filter for activity entities.
+     * 
+     * @param activityID The ID of the activity
+     * @return a new QueryAuditLogsFilters for the activity
+     */
+    public static QueryAuditLogsFilters forActivity(String activityID) {
+        return forEntity("activity", activityID);
+    }
+    
+    /**
+     * Convenience method to create a filter for reaction entities.
+     * 
+     * @param reactionID The ID of the reaction
+     * @return a new QueryAuditLogsFilters for the reaction
+     */
+    public static QueryAuditLogsFilters forReaction(String reactionID) {
+        return forEntity("reaction", reactionID);
+    }
+    
     public String getEntityType() {
         return entityType;
     }
@@ -62,7 +88,7 @@ public String getUserID() {
     /**
      * Set the entity type for existing filter instance.
      * 
-     * @param entityType The type of entity
+     * @param entityType The type of entity (e.g., "activity", "reaction")
      * @return this instance for method chaining
      */
     public QueryAuditLogsFilters setEntityType(String entityType) {
@@ -134,7 +160,7 @@ private Builder() {
         /**
          * Set the entity type.
          * 
-         * @param entityType The type of entity (e.g., "user", "feed")
+         * @param entityType The type of entity (e.g., "activity", "reaction")
          * @return this builder for method chaining
          */
         public Builder withEntityType(String entityType) {

src/test/java/io/getstream/client/AuditLogsClientIntegrationTest.java

@@ -1,167 +1,56 @@
 package io.getstream.client;
 
-import io.getstream.core.exceptions.StreamAPIException;
 import io.getstream.core.exceptions.StreamException;
 import io.getstream.core.models.Activity;
-import io.getstream.core.models.AuditLog;
 import org.junit.Before;
 import org.junit.Test;
-import java.util.Date;
-import java.util.List;
-import java.util.concurrent.CompletionException;
-
 import static org.junit.Assert.*;
-import static org.junit.Assume.assumeTrue;
 
 /**
  * Integration test for the AuditLogsClient
  * Uses a Stream app with audit logs enabled
  */
 public class AuditLogsClientIntegrationTest {
     // Credentials for a Stream app with audit logs enabled
-    private static final String apiKey = "cahwc7wn4qs9";
-    private static final String secret = "x7psq92284cmn2j9wkhdjyrum9va7h6d6m5cbm9ryjgv649surzj9fdex34u6utn";
-    
+    private static final String apiKey =
+            System.getenv("STREAM_KEY") != null
+                    ? System.getenv("STREAM_KEY")
+                    : System.getProperty("STREAM_KEY");
+    private static final String secret =
+            System.getenv("STREAM_SECRET") != null
+                    ? System.getenv("STREAM_SECRET")
+                    : System.getProperty("STREAM_SECRET");
+
     private Client client;
-    private boolean hasValidCredentials = false;
 
     @Before
     public void setUp() throws Exception {
-        if (apiKey != null && !apiKey.isEmpty() && secret != null && !secret.isEmpty()) {
-            client = Client.builder(apiKey, secret).region("oregon").build();
-            hasValidCredentials = true;
-        }
+        client = Client.builder(apiKey, secret).build();
     }
 
+
     @Test
     public void testQueryAuditLogs() throws StreamException {
-        // Skip test if credentials aren't available
-        assumeTrue("Skipping test due to missing API credentials", hasValidCredentials);
-        
-        // Test querying audit logs with a user filter (required by the API)
-        // Using the builder pattern for better flexibility
-        QueryAuditLogsFilters filters = QueryAuditLogsFilters.forUser("admin");
+        FlatFeed userFeed = client.flatFeed("user", "1");
+        Activity a = Activity.builder().actor("userid:1").verb("tweet").object("Tweet:1").build();
+        a = userFeed.addActivity(a).join();
+
+        // Using the convenience method for activity entities
         QueryAuditLogsPager pager = new QueryAuditLogsPager(5); // limit to 5 results
-        
+        QueryAuditLogsFilters filters = QueryAuditLogsFilters.forActivity(a.getID());
         QueryAuditLogsResponse response = client.auditLogs().queryAuditLogs(filters, pager).join();
-        
-        // Verify response structure
-        assertNotNull("Response should not be null", response);
-        assertNotNull("Audit logs list should not be null", response.getAuditLogs());
-        assertNotNull("Duration should not be null", response.getDuration());
-        
-        // Test that audit logs list is properly initialized (even if empty)
-        assertTrue("Audit logs list should be accessible", response.getAuditLogs() != null);
-        
-        // Verify that pagination properties exist
-        // Note: they might be null if no pagination is needed
-        // but the fields themselves should exist
-        assertNotNull("Response object should contain next field (even if null)", response);
-        assertNotNull("Response object should contain prev field (even if null)", response);
-    }
-    
-    @Test
-    public void testQueryAuditLogsByEntityType() throws StreamException {
-        // Skip test if credentials aren't available
-        assumeTrue("Skipping test due to missing API credentials", hasValidCredentials);
-        
-        // Test querying audit logs by entity type and ID
-        // Using the static factory method for entity-based filters
-        QueryAuditLogsFilters filters = QueryAuditLogsFilters.forEntity("user", "user-123");
-        QueryAuditLogsPager pager = new QueryAuditLogsPager(5);
-        
-        QueryAuditLogsResponse response = client.auditLogs().queryAuditLogs(filters, pager).join();
-        
+
         // Verify response structure
         assertNotNull("Response should not be null", response);
         assertNotNull("Audit logs list should not be null", response.getAuditLogs());
-        assertNotNull("Duration should not be null", response.getDuration());
-        
-        // Validate that filters worked properly - if we have any logs for this entity
-        if (!response.getAuditLogs().isEmpty()) {
-            for (AuditLog log : response.getAuditLogs()) {
-                if (log.getEntityType() != null && log.getEntityID() != null) {
-                    assertEquals("Entity type should match filter", "user", log.getEntityType());
-                    assertEquals("Entity ID should match filter", "user-123", log.getEntityID());
-                }
-            }
-        }
-    }
-    
-    @Test
-    public void testInvalidFilters() throws StreamException {
-        // No need to check credentials since this doesn't make an API call
-        
-        // Test that validation works for invalid filters
-        // Using the builder with no values set
-        QueryAuditLogsFilters filters = QueryAuditLogsFilters.builder().build();
-        
-        // Use a different approach since JUnit 4 doesn't have assertThrows
-        try {
-            filters.validate();
-            fail("Should have thrown an exception for invalid filters");
-        } catch (StreamException e) {
-            // Expected exception
-            assertEquals("Error message should match validation message",
-                    "Either entityType+entityID or userID is required for audit logs queries", 
-                    e.getMessage());
-        }
-    }
-
-    @Test
-    public void testQueryAuditLogs2() throws StreamException {
-        // Skip test if credentials aren't available
-        assumeTrue("Skipping test due to missing API credentials", hasValidCredentials);
-        
-        try {
-            FlatFeed userFeed = client.flatFeed("user", "1");
-            Activity a = Activity.builder().actor("userid:1").verb("tweet").object("Tweet:1").build();
-            userFeed.addActivities(a).join();
+        assertNotEquals(0, response.getAuditLogs().size());
 
-            // Using the builder pattern with chainable methods for complex filters
-            QueryAuditLogsFilters filters = QueryAuditLogsFilters.builder()
-                    .withEntityType("activity")
-                    .withEntityID("userid:1")
-                    .build();
+        filters = QueryAuditLogsFilters.forUser("userid:1");
+        response = client.auditLogs().queryAuditLogs(filters, pager).join();
 
-            QueryAuditLogsPager pager = new QueryAuditLogsPager(5); // limit to 5 results
-
-            QueryAuditLogsResponse response = client.auditLogs().queryAuditLogs(filters, pager).join();
-
-            // Verify response structure
-            assertNotNull("Response should not be null", response);
-            assertNotNull("Audit logs list should not be null", response.getAuditLogs());
-            assertNotNull("Duration should not be null", response.getDuration());
-        } catch (Exception e) {
-            // In case of any error with the activity creation, just log and continue
-            System.err.println("Test encountered error: " + e.getMessage());
-            // Don't fail the test as this is just testing the audit logs API functionality
-        }
-    }
-    
-    @Test
-    public void testMixedFilters() throws StreamException {
-        // Skip test if credentials aren't available
-        assumeTrue("Skipping test due to missing API credentials", hasValidCredentials);
-        
-        // Test creating a filter with both entity and user information
-        QueryAuditLogsFilters filters = QueryAuditLogsFilters.builder()
-                .withEntityType("feed")
-                .withEntityID("user:123")
-                .withUserID("admin")
-                .build();
-        
-        QueryAuditLogsPager pager = new QueryAuditLogsPager(5);
-        
-        QueryAuditLogsResponse response = client.auditLogs().queryAuditLogs(filters, pager).join();
-        
         // Verify response structure
         assertNotNull("Response should not be null", response);
         assertNotNull("Audit logs list should not be null", response.getAuditLogs());
-        assertNotNull("Duration should not be null", response.getDuration());
-        
-        // Since we've used both entity and user filters, API will prioritize one based on its implementation
-        // Just verify we got a valid response back
-        assertTrue("Response should be properly constructed", response != null && response.getAuditLogs() != null);
+        assertNotEquals(0, response.getAuditLogs().size());
     }
-} 
+}

src/test/java/io/getstream/client/AuditLogsClientTest.java

@@ -91,7 +91,7 @@ public void setUp() throws Exception {
 
     @Test
     public void testQueryAuditLogs() throws Exception {
-        QueryAuditLogsFilters filters = QueryAuditLogsFilters.forEntity("user", "user-123");
+        QueryAuditLogsFilters filters = QueryAuditLogsFilters.forEntity("activity", "activity-123");
         QueryAuditLogsPager pager = new QueryAuditLogsPager(10);
 
         QueryAuditLogsResponse response = client.auditLogs().queryAuditLogs(filters, pager).join();
@@ -126,8 +126,8 @@ public void testQueryAuditLogs() throws Exception {
         String urlQuery = lastRequest.getURL().getQuery();
         Map<String, String> queryParams = extractQueryParams(urlQuery);
 
-        assertEquals("user", queryParams.get("entity_type"));
-        assertEquals("user-123", queryParams.get("entity_id"));
+        assertEquals("activity", queryParams.get("entity_type"));
+        assertEquals("activity-123", queryParams.get("entity_id"));
         assertEquals("10", queryParams.get("limit"));
     }
 
@@ -192,8 +192,8 @@ public void testQueryAuditLogsTokenGeneration() throws Exception {
     public void testBuilderPatternFlexibility() throws Exception {
         // Test the full builder pattern flexibility
         QueryAuditLogsFilters filters = QueryAuditLogsFilters.builder()
-            .withEntityType("feed")
-            .withEntityID("user:123")
+            .withEntityType("reaction")
+            .withEntityID("reaction-123")
             .withUserID("admin")
             .build();
 
@@ -207,11 +207,49 @@ public void testBuilderPatternFlexibility() throws Exception {
         String urlQuery = lastRequest.getURL().getQuery();
         Map<String, String> queryParams = extractQueryParams(urlQuery);
 
-        assertEquals("feed", queryParams.get("entity_type"));
-        assertEquals("user:123", queryParams.get("entity_id"));
+        assertEquals("reaction", queryParams.get("entity_type"));
+        assertEquals("reaction-123", queryParams.get("entity_id"));
         assertEquals("admin", queryParams.get("user_id"));
     }
 
+    @Test
+    public void testForActivityConvenienceMethod() throws Exception {
+        // Test the convenience method for activities
+        QueryAuditLogsFilters filters = QueryAuditLogsFilters.forActivity("activity-789");
+        
+        client.auditLogs().queryAuditLogs(filters).join();
+        
+        // Verify request parameters
+        Request lastRequest = mockHTTPClient.lastRequest;
+        assertNotNull(lastRequest);
+        
+        // Extract query parameters from URL
+        String urlQuery = lastRequest.getURL().getQuery();
+        Map<String, String> queryParams = extractQueryParams(urlQuery);
+        
+        assertEquals("activity", queryParams.get("entity_type"));
+        assertEquals("activity-789", queryParams.get("entity_id"));
+    }
+    
+    @Test
+    public void testForReactionConvenienceMethod() throws Exception {
+        // Test the convenience method for reactions
+        QueryAuditLogsFilters filters = QueryAuditLogsFilters.forReaction("reaction-456");
+        
+        client.auditLogs().queryAuditLogs(filters).join();
+        
+        // Verify request parameters
+        Request lastRequest = mockHTTPClient.lastRequest;
+        assertNotNull(lastRequest);
+        
+        // Extract query parameters from URL
+        String urlQuery = lastRequest.getURL().getQuery();
+        Map<String, String> queryParams = extractQueryParams(urlQuery);
+        
+        assertEquals("reaction", queryParams.get("entity_type"));
+        assertEquals("reaction-456", queryParams.get("entity_id"));
+    }
+    
     private Map<String, String> extractQueryParams(String query) {
         if (query == null || query.isEmpty()) {
             return Collections.emptyMap();