fix(client): correct default for listing subjects

Signed-off-by: Raphael Höser <[email protected]>

Author: Snapstromegon

README.md

@@ -12,5 +12,5 @@ Based on the [compliance criteria](https://docs.eventsourcingdb.io/client-sdks/c
 - ❌ [Reading Events](https://docs.eventsourcingdb.io/client-sdks/compliance-criteria/#reading-events)
 - ❌ [Using EventQL](https://docs.eventsourcingdb.io/client-sdks/compliance-criteria/#using-eventql)
 - ❌ [Observing Events](https://docs.eventsourcingdb.io/client-sdks/compliance-criteria/#observing-events)
-- ❌ [Metadata and Discovery](https://docs.eventsourcingdb.io/client-sdks/compliance-criteria/#metadata-and-discovery)
+- 🚀 [Metadata and Discovery](https://docs.eventsourcingdb.io/client-sdks/compliance-criteria/#metadata-and-discovery)
 - 🚀 [Testcontainers Support](https://docs.eventsourcingdb.io/client-sdks/compliance-criteria/#testcontainers-support)

src/client.rs

@@ -20,7 +20,9 @@
 mod client_request;
 
 use client_request::{
-    list_event_types::EventType, ClientRequest, ListEventTypesRequest, ListSubjectsRequest, OneShotRequest, PingRequest, RegisterEventSchemaRequest, StreamingRequest, VerifyApiTokenRequest
+    ClientRequest, ListEventTypesRequest, ListSubjectsRequest, OneShotRequest, PingRequest,
+    RegisterEventSchemaRequest, StreamingRequest, VerifyApiTokenRequest,
+    list_event_types::EventType,
 };
 
 use futures::Stream;
@@ -214,7 +216,9 @@ impl Client {
         base_subject: Option<&str>,
     ) -> Result<impl Stream<Item = Result<String, ClientError>>, ClientError> {
         let response = self
-            .request_streaming(ListSubjectsRequest { base_subject })
+            .request_streaming(ListSubjectsRequest {
+                base_subject: base_subject.unwrap_or("/"),
+            })
             .await?;
         Ok(response)
     }

src/client/client_request/list_event_types.rs

@@ -7,7 +7,9 @@ use crate::error::ClientError;
 
 use super::{ClientRequest, StreamingRequest};
 #[derive(Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
 pub struct EventType {
+    #[serde(rename = "eventType")]
     pub name: String,
     pub is_phantom: bool,
     pub schema: Option<Value>,
@@ -33,15 +35,16 @@ impl StreamingRequest for ListEventTypesRequest {
         response: reqwest::Response,
     ) -> impl Stream<Item = Result<Self::ItemType, ClientError>> {
         #[derive(Deserialize, Debug)]
+        #[serde(tag = "type", content = "payload", rename_all = "camelCase")]
         enum LineItem {
-            Error(String),
+            Error { error: String },
             EventType(EventType),
         }
 
         impl From<LineItem> for Result<EventType, ClientError> {
             fn from(item: LineItem) -> Self {
                 match item {
-                    LineItem::Error(err) => Err(ClientError::DBError(err)),
+                    LineItem::Error { error } => Err(ClientError::DBError(error)),
                     LineItem::EventType(event_type) => Ok(event_type),
                 }
             }

src/client/client_request/list_subjects.rs

@@ -9,7 +9,7 @@ use super::{ClientRequest, StreamingRequest};
 #[derive(Debug, Clone, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ListSubjectsRequest<'a> {
-    pub base_subject: Option<&'a str>,
+    pub base_subject: &'a str,
 }
 
 impl<'a> ClientRequest for ListSubjectsRequest<'a> {

tests/metadata_and_discovery.rs

@@ -1,4 +1,5 @@
 use eventsourcingdb_client_rust::container::Container;
+use futures::StreamExt;
 use serde_json::json;
 
 #[tokio::test]
@@ -25,7 +26,6 @@ async fn register_event_schema() {
         .expect("Failed to register event schema");
 }
 
-
 #[tokio::test]
 async fn register_invalid_event_schema() {
     let container = Container::start_default().await.unwrap();
@@ -40,3 +40,81 @@ async fn register_invalid_event_schema() {
         .await;
     assert!(res.is_err(), "Expected an error, but got: {:?}", res);
 }
+
+#[tokio::test]
+async fn list_all_subjects() {
+    let container = Container::start_default().await.unwrap();
+    let client = container.get_client().await.unwrap();
+    let res = client.list_subjects(None).await;
+    match res {
+        Ok(subjects) => {
+            let subjects = subjects.collect::<Vec<_>>().await;
+            assert!(
+                subjects.is_empty(),
+                "Expected no subjects, but got: {:?}",
+                subjects
+            );
+        }
+        Err(err) => panic!("Failed to list subjects: {:?}", err),
+    }
+}
+
+//TODO!: add list all subjects test after writing to db
+
+//TODO!: add list scoped subjects test after writing to db
+
+#[tokio::test]
+async fn list_all_event_types() {
+    let container = Container::start_default().await.unwrap();
+    let client = container.get_client().await.unwrap();
+    let test_event_type = "io.eventsourcingdb.test";
+    let schema = json!({
+        "type": "object",
+        "properties": {
+            "id": {
+                "type": "string"
+            },
+            "name": {
+                "type": "string"
+            }
+        },
+        "required": ["id", "name"]
+    });
+    client
+        .register_event_schema(test_event_type, &schema)
+        .await
+        .expect("Failed to register event schema");
+    let res = client.list_event_types().await;
+    match res {
+        Ok(event_types) => {
+            let mut event_types = event_types.collect::<Vec<_>>().await;
+            assert!(
+                event_types.len() == 1,
+                "Expected one event types, but got: {:?}",
+                event_types
+            );
+            assert!(event_types[0].is_ok(), "Expected event type to be ok");
+            let response_event_type = event_types.pop().unwrap().unwrap();
+            assert_eq!(
+                response_event_type.name, test_event_type,
+                "Expected event type to be 'io.eventsourcingdb.test', but got: {:?}",
+                response_event_type.name
+            );
+            assert_eq!(
+                response_event_type.schema.as_ref(),
+                Some(&schema),
+                "Expected event type schema to be {:?}, but got: {:?}",
+                schema,
+                response_event_type.schema
+            );
+            assert!(
+                response_event_type.is_phantom,
+                "Expected event type is_phantom to be true, but got: {:?}",
+                response_event_type.is_phantom
+            );
+        }
+        Err(err) => panic!("Failed to list event types: {:?}", err),
+    }
+}
+
+// TODO!: add list event types test after writing to db