Add comprehensive unit tests, integration tests, and Docker environment

- Add 161 unit tests across all modules (types, info, utils, client, http,
  sirix, database, resource) using mockito for behavioral HTTP testing
- Add 20 integration tests in tests/sirix.rs exercising the full API against
  a running SirixDB server (database CRUD, resource CRUD, read, update,
  history, diff, query, metadata, etag, delete_all)
- Modernize Docker environment to match sirix-python-client:
  - Upgrade Keycloak from 7.0.1 to 25.0.1 with custom Dockerfile
  - Add Docker bridge network, healthchecks, and service dependencies
  - Add wait-for-keycloak.sh entrypoint and kcadm.sh user setup
  - Add logback-test.xml for SirixDB logging
- Update CI workflow with separate unit test and integration test steps
- Add test.sh for local Docker-based test orchestration
- Make InfoResultWithResources fields public for integration test access

https://claude.ai/code/session_01LgXiks4zqYLRVbkgmCNoGc

Author: claude

.github/workflows/rust.yml

@@ -2,16 +2,24 @@ name: Rust
 
 on: [push]
 
+env:
+  GITHUB_ACTIONS: "true"
+
 jobs:
   build:
 
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: setup SirixDB server
-      run: docker-compose -f ./tests/resources/docker-compose.yml up -d keycloak
+    - uses: actions/checkout@v4
     - name: Build crate
       run: cargo build --all-features --verbose
-    - name: Run tests
-      run: bash ./prepare-test.sh && cargo test --all-features --verbose
+    - name: Run unit tests
+      run: cargo test --all-features --verbose --lib
+    - name: Setup SirixDB environment
+      run: bash ./prepare-test.sh
+    - name: Run all tests (unit + integration)
+      run: cargo test --all-features --verbose
+    - name: Teardown
+      if: always()
+      run: docker-compose -f ./tests/resources/docker-compose.yml down -v --remove-orphans 2>/dev/null || true

prepare-test.sh

@@ -1,4 +1,43 @@
-echo "starting the docker environment"
-bash ./tests/resources/wait.sh
-docker-compose -f ./tests/resources/docker-compose.yml up -d server
-sleep 5
+#!/bin/bash
+set -e
+
+COMPOSE_FILE="./tests/resources/docker-compose.yml"
+
+echo "Starting Docker environment..."
+docker-compose -f "$COMPOSE_FILE" up -d --build
+
+echo "Waiting for Keycloak to become healthy..."
+timeout=300
+elapsed=0
+while [ $elapsed -lt $timeout ]; do
+  if docker-compose -f "$COMPOSE_FILE" ps keycloak | grep -q "healthy"; then
+    echo "Keycloak is healthy."
+    break
+  fi
+  sleep 5
+  elapsed=$((elapsed + 5))
+done
+
+if [ $elapsed -ge $timeout ]; then
+  echo "ERROR: Keycloak did not become healthy within ${timeout}s"
+  docker-compose -f "$COMPOSE_FILE" logs keycloak
+  exit 1
+fi
+
+echo "Waiting for SirixDB to be ready..."
+timeout=120
+elapsed=0
+while [ $elapsed -lt $timeout ]; do
+  if curl -sf http://localhost:9443 > /dev/null 2>&1; then
+    echo "SirixDB is ready!"
+    break
+  fi
+  sleep 5
+  elapsed=$((elapsed + 5))
+done
+
+if [ $elapsed -ge $timeout ]; then
+  echo "ERROR: SirixDB did not become ready within ${timeout}s"
+  docker-compose -f "$COMPOSE_FILE" logs server
+  exit 1
+fi

src/asynchronous/client.rs

@@ -95,6 +95,51 @@ pub async fn request_impl<T: DeserializeOwned>(
     }
 }
 
+pub async fn request_impl_string(
+    channel: Sender<Message>,
+    scheme: Scheme,
+    authority: Authority,
+    path_and_query: PathAndQuery,
+    method: Method,
+    headers: HeaderMap,
+    body: Body,
+) -> SirixResult<SirixResponse<String>> {
+    let uri = Uri::builder()
+        .scheme(scheme)
+        .authority(authority)
+        .path_and_query(path_and_query)
+        .build()
+        .unwrap();
+    // create request
+    let mut request_builder = Request::builder().uri(uri).method(method);
+    for header in headers {
+        request_builder = request_builder.header(header.0.unwrap(), header.1);
+    }
+    let request = request_builder.body(body).unwrap();
+    // create response channel
+    let (tx, rx) = oneshot::channel::<ResultResponse>();
+    // Perform request
+    let _ = channel
+        .send(Message {
+            request: request,
+            responder: tx,
+        })
+        .await;
+    let response = rx.await.unwrap().unwrap();
+    let status = response.status().clone();
+    let headers = response.headers().clone();
+    // Aggregate body
+    let body = body::aggregate(response).await?;
+    let mut buf: Vec<u8> = vec![];
+    std::io::Read::read_to_end(&mut body.reader(), &mut buf).unwrap();
+
+    Ok(SirixResponse {
+        headers: headers.to_owned(),
+        status: status,
+        body: String::from_utf8_lossy(&buf).into_owned(),
+    })
+}
+
 pub async fn request_impl_fire_no_response(
     channel: Sender<Message>,
     scheme: Scheme,

src/asynchronous/database.rs

@@ -3,10 +3,11 @@
 use super::super::info::TokenData;
 use super::super::types::{DbInfo, DbType, Json, Xml};
 use super::client::{Message, SirixResponse};
-use super::http::{create_database, delete_database, get_database_info};
+use super::http::{create_database, delete_database, get_database_info, get_database_info_string};
 use super::resource::Resource;
 use super::SirixResult;
 use hyper::http::uri::{Authority, Scheme};
+use serde::de::DeserializeOwned;
 use tokio::sync::mpsc::Sender;
 use tokio::sync::watch::Receiver;
 
@@ -30,6 +31,10 @@ pub struct Database<T> {
 
 impl<T> Database<T> {
     pub async fn info(&self) -> SirixResult<SirixResponse<DbInfo>> {
+        self.info_raw().await
+    }
+
+    pub async fn info_raw<U: DeserializeOwned>(&self) -> SirixResult<SirixResponse<U>> {
         match self.auth_channel.clone() {
             Some(watcher) => {
                 let token_data = watcher.borrow().as_ref().unwrap().clone();
@@ -56,6 +61,33 @@ impl<T> Database<T> {
         }
     }
 
+    pub async fn info_string(&self) -> SirixResult<SirixResponse<String>> {
+        match self.auth_channel.clone() {
+            Some(watcher) => {
+                let token_data = watcher.borrow().as_ref().unwrap().clone();
+                let token = token_data.token_type + " " + &token_data.access_token;
+                get_database_info_string(
+                    self.scheme.clone(),
+                    self.authority.clone(),
+                    &self.db_name,
+                    Some(&token),
+                    self.channel.clone(),
+                )
+                .await
+            }
+            None => {
+                get_database_info_string(
+                    self.scheme.clone(),
+                    self.authority.clone(),
+                    &self.db_name,
+                    None,
+                    self.channel.clone(),
+                )
+                .await
+            }
+        }
+    }
+
     pub async fn delete(&self) -> SirixResult<SirixResponse<()>> {
         match self.auth_channel.clone() {
             Some(watcher) => {