feat: add integration tests and runnable examples

Add 91 integration tests (all #[ignore]) mirroring the JavaScript SDK's
integration test suite. Tests cover all endpoints: ping, apps, fields,
records, files, lists, and reports with success, auth, access, and
not-found scenarios.

Add 7 runnable examples (cargo run --example <name>) for quick manual
smoke testing against a real Onspring instance.

Both use env vars (API_BASE_URL, SANDBOX_API_KEY, TEST_*) matching the
JavaScript SDK setup.

Also rename crate to onspring-api-sdk-rust with [lib] name = "onspring"
so imports remain `use onspring::*`.

tests/integration_apps.rs

@@ -0,0 +1,115 @@
+mod integration_common;
+
+use integration_common::*;
+use onspring::PagingRequest;
+
+#[tokio::test]
+#[ignore]
+async fn list_apps_should_return_apps() {
+  let client = build_client();
+  let response = client.list_apps(None).await.unwrap();
+
+  assert!(response.total_records.unwrap() > 0);
+  let items = response.items.unwrap();
+  assert!(!items.is_empty());
+
+  for app in &items {
+    assert!(app.id > 0);
+    assert!(app.name.is_some());
+    assert!(app.href.is_some());
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_apps_should_respect_paging() {
+  let client = build_client();
+  let paging = PagingRequest {
+    page_number: 1,
+    page_size: 1,
+  };
+  let response = client.list_apps(Some(paging)).await.unwrap();
+
+  assert_eq!(response.page_number.unwrap(), 1);
+  assert_eq!(response.page_size.unwrap(), 1);
+  assert_eq!(response.items.unwrap().len(), 1);
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_apps_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.list_apps(None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_app_should_return_app() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID");
+  let app = client.get_app(app_id).await.unwrap();
+
+  assert_eq!(app.id, app_id);
+  assert!(app.name.is_some());
+  assert!(app.href.is_some());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_app_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.get_app(1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_app_should_fail_when_not_found() {
+  let client = build_client();
+  let result = client.get_app(0).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_app_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let result = client.get_app(app_id).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_apps_should_return_apps() {
+  let client = build_client();
+  let app_ids = required_env_csv_i32("TEST_APP_IDS");
+  let response = client.batch_get_apps(&app_ids).await.unwrap();
+
+  let items = response.items.unwrap();
+  assert_eq!(items.len(), app_ids.len());
+
+  for app in &items {
+    assert!(app.id > 0);
+    assert!(app.name.is_some());
+    assert!(app.href.is_some());
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_apps_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.batch_get_apps(&[1]).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_apps_should_fail_when_no_access() {
+  let client = build_client();
+  let app_ids = required_env_csv_i32("TEST_APP_IDS_NO_ACCESS");
+  let result = client.batch_get_apps(&app_ids).await;
+  assert!(result.is_err());
+}

tests/integration_common/mod.rs

@@ -0,0 +1,54 @@
+use onspring::OnspringClient;
+use std::collections::HashMap;
+
+pub fn required_env(name: &str) -> String {
+  std::env::var(name).unwrap_or_else(|_| panic!("{} is not defined", name))
+}
+
+pub fn required_env_i32(name: &str) -> i32 {
+  required_env(name)
+    .parse()
+    .unwrap_or_else(|_| panic!("{} is not a valid integer", name))
+}
+
+pub fn required_env_csv_i32(name: &str) -> Vec<i32> {
+  required_env(name)
+    .split(',')
+    .map(|s| {
+      s.trim()
+        .parse()
+        .unwrap_or_else(|_| panic!("{} contains non-integer values", name))
+    })
+    .collect()
+}
+
+pub fn build_client() -> OnspringClient {
+  let base_url = required_env("API_BASE_URL");
+  let api_key = required_env("SANDBOX_API_KEY");
+  OnspringClient::builder(&api_key)
+    .base_url(&base_url)
+    .build()
+}
+
+pub fn build_client_with_key(api_key: &str) -> OnspringClient {
+  let base_url = required_env("API_BASE_URL");
+  OnspringClient::builder(api_key).base_url(&base_url).build()
+}
+
+pub async fn add_record() -> i32 {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let field_id = required_env("TEST_TEXT_FIELD");
+
+  let mut fields = HashMap::new();
+  fields.insert(field_id, serde_json::json!("test"));
+
+  let request = onspring::SaveRecordRequest {
+    app_id,
+    record_id: None,
+    fields,
+  };
+
+  let response = client.save_record(request).await.unwrap();
+  response.id
+}

tests/integration_fields.rs

@@ -0,0 +1,126 @@
+mod integration_common;
+
+use integration_common::*;
+use onspring::PagingRequest;
+
+#[tokio::test]
+#[ignore]
+async fn get_field_should_return_field() {
+  let client = build_client();
+  let field_id = required_env_i32("TEST_FIELD_ID");
+  let field = client.get_field(field_id).await.unwrap();
+
+  assert_eq!(field.id, field_id);
+  assert!(field.name.is_some());
+  assert!(field.app_id > 0);
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_field_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.get_field(1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_field_should_fail_when_no_access() {
+  let client = build_client();
+  let field_id = required_env_i32("TEST_FIELD_ID_NO_ACCESS");
+  let result = client.get_field(field_id).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_field_should_fail_when_not_found() {
+  let client = build_client();
+  let result = client.get_field(0).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_fields_should_return_fields() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let response = client.list_fields(app_id, None).await.unwrap();
+
+  assert!(response.total_records.unwrap() > 0);
+  let items = response.items.unwrap();
+  assert!(!items.is_empty());
+
+  for field in &items {
+    assert!(field.id > 0);
+    assert!(field.name.is_some());
+    assert!(field.app_id > 0);
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_fields_should_respect_paging() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let paging = PagingRequest {
+    page_number: 1,
+    page_size: 1,
+  };
+  let response = client.list_fields(app_id, Some(paging)).await.unwrap();
+
+  assert_eq!(response.page_number.unwrap(), 1);
+  assert_eq!(response.page_size.unwrap(), 1);
+  assert_eq!(response.items.unwrap().len(), 1);
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_fields_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.list_fields(1, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_fields_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let result = client.list_fields(app_id, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_fields_should_return_fields() {
+  let client = build_client();
+  let field_ids = required_env_csv_i32("TEST_FIELD_IDS");
+  let response = client.batch_get_fields(&field_ids).await.unwrap();
+
+  let items = response.items.unwrap();
+  assert_eq!(items.len(), field_ids.len());
+
+  for field in &items {
+    assert!(field.id > 0);
+    assert!(field.name.is_some());
+    assert!(field.app_id > 0);
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_fields_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.batch_get_fields(&[1, 2, 3]).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_fields_should_fail_when_no_access() {
+  let client = build_client();
+  let field_ids = required_env_csv_i32("TEST_FIELD_IDS_NO_ACCESS");
+  let result = client.batch_get_fields(&field_ids).await;
+  assert!(result.is_err());
+}

tests/integration_files.rs

@@ -0,0 +1,340 @@
+mod integration_common;
+
+use integration_common::*;
+use onspring::SaveFileRequest;
+
+#[tokio::test]
+#[ignore]
+async fn get_file_info_for_attachment_should_return_info() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD");
+  let file_id = required_env_i32("TEST_ATTACHMENT");
+
+  let info = client
+    .get_file_info(record_id, field_id, file_id)
+    .await
+    .unwrap();
+
+  assert!(info.name.is_some());
+  assert!(info.content_type.is_some());
+  assert!(info.created_date.is_some());
+  assert!(info.modified_date.is_some());
+  assert!(info.file_href.is_some());
+  assert!(info.owner.is_some());
+  assert!(info.file_type.is_some());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_info_for_image_should_return_info() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_IMAGE_FIELD");
+  let file_id = required_env_i32("TEST_IMAGE");
+
+  let info = client
+    .get_file_info(record_id, field_id, file_id)
+    .await
+    .unwrap();
+
+  assert!(info.name.is_some());
+  assert!(info.content_type.is_some());
+  assert!(info.created_date.is_some());
+  assert!(info.modified_date.is_some());
+  assert!(info.file_href.is_some());
+  assert!(info.owner.is_some());
+  assert!(info.file_type.is_some());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_info_should_fail_for_non_file_field() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_TEXT_FIELD");
+  let file_id = required_env_i32("TEST_ATTACHMENT");
+
+  let result = client.get_file_info(record_id, field_id, file_id).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_info_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD");
+  let file_id = required_env_i32("TEST_ATTACHMENT");
+
+  let result = client.get_file_info(record_id, field_id, file_id).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_info_should_fail_when_no_field_access() {
+  let client = build_client();
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD_NO_ACCESS_FIELD");
+  let result = client.get_file_info(1, field_id, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_info_should_fail_when_no_app_access() {
+  let client = build_client();
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD_NO_ACCESS_APP");
+  let result = client.get_file_info(1, field_id, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_info_should_fail_when_field_not_found() {
+  let client = build_client();
+  let result = client.get_file_info(1, 0, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_info_should_fail_when_record_not_found() {
+  let client = build_client();
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD");
+  let result = client.get_file_info(0, field_id, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_for_attachment_should_return_file() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD");
+  let file_id = required_env_i32("TEST_ATTACHMENT");
+
+  let response = client.get_file(record_id, field_id, file_id).await.unwrap();
+
+  assert!(response.content_type.is_some());
+  assert!(response.file_name.is_some());
+  assert!(!response.data.is_empty());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_for_image_should_return_file() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_IMAGE_FIELD");
+  let file_id = required_env_i32("TEST_IMAGE");
+
+  let response = client.get_file(record_id, field_id, file_id).await.unwrap();
+
+  assert!(response.content_type.is_some());
+  assert!(response.file_name.is_some());
+  assert!(!response.data.is_empty());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_file_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD");
+  let file_id = required_env_i32("TEST_ATTACHMENT");
+
+  let result = client.get_file(record_id, field_id, file_id).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn upload_file_to_attachment_field_should_succeed() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD");
+
+  let file_data = std::fs::read("tests/test_data/test-attachment.txt").unwrap();
+
+  let request = SaveFileRequest {
+    record_id,
+    field_id,
+    notes: Some("integration test".to_string()),
+    modified_date: Some(chrono::Utc::now()),
+    file_name: "test-attachment.txt".to_string(),
+    file_data,
+    content_type: "text/plain".to_string(),
+  };
+
+  let response = client.upload_file(request).await.unwrap();
+  assert!(response.id > 0);
+
+  // Cleanup
+  let _ = client.delete_file(record_id, field_id, response.id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn upload_file_to_image_field_should_succeed() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_IMAGE_FIELD");
+
+  let file_data = std::fs::read("tests/test_data/test-image.jpeg").unwrap();
+
+  let request = SaveFileRequest {
+    record_id,
+    field_id,
+    notes: Some("integration test".to_string()),
+    modified_date: Some(chrono::Utc::now()),
+    file_name: "test-image.jpeg".to_string(),
+    file_data,
+    content_type: "image/jpeg".to_string(),
+  };
+
+  let response = client.upload_file(request).await.unwrap();
+  assert!(response.id > 0);
+
+  // Cleanup
+  let _ = client.delete_file(record_id, field_id, response.id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn upload_file_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+
+  let request = SaveFileRequest {
+    record_id: 1,
+    field_id: 1,
+    notes: Some("test".to_string()),
+    modified_date: Some(chrono::Utc::now()),
+    file_name: "test.txt".to_string(),
+    file_data: b"test".to_vec(),
+    content_type: "text/plain".to_string(),
+  };
+
+  let result = client.upload_file(request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn upload_file_should_fail_for_non_file_field() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_TEXT_FIELD");
+
+  let file_data = std::fs::read("tests/test_data/test-attachment.txt").unwrap();
+
+  let request = SaveFileRequest {
+    record_id,
+    field_id,
+    notes: Some("test".to_string()),
+    modified_date: Some(chrono::Utc::now()),
+    file_name: "test-attachment.txt".to_string(),
+    file_data,
+    content_type: "text/plain".to_string(),
+  };
+
+  let result = client.upload_file(request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_file_from_attachment_should_succeed() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD");
+
+  // Upload first
+  let file_data = std::fs::read("tests/test_data/test-attachment.txt").unwrap();
+  let request = SaveFileRequest {
+    record_id,
+    field_id,
+    notes: Some("to be deleted".to_string()),
+    modified_date: Some(chrono::Utc::now()),
+    file_name: "test-attachment.txt".to_string(),
+    file_data,
+    content_type: "text/plain".to_string(),
+  };
+  let uploaded = client.upload_file(request).await.unwrap();
+
+  // Delete
+  client
+    .delete_file(record_id, field_id, uploaded.id)
+    .await
+    .unwrap();
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_file_from_image_should_succeed() {
+  let client = build_client();
+  let record_id = required_env_i32("TEST_RECORD");
+  let field_id = required_env_i32("TEST_IMAGE_FIELD");
+
+  // Upload first
+  let file_data = std::fs::read("tests/test_data/test-image.jpeg").unwrap();
+  let request = SaveFileRequest {
+    record_id,
+    field_id,
+    notes: Some("to be deleted".to_string()),
+    modified_date: Some(chrono::Utc::now()),
+    file_name: "test-image.jpeg".to_string(),
+    file_data,
+    content_type: "image/jpeg".to_string(),
+  };
+  let uploaded = client.upload_file(request).await.unwrap();
+
+  // Delete
+  client
+    .delete_file(record_id, field_id, uploaded.id)
+    .await
+    .unwrap();
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_file_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.delete_file(1, 1, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_file_should_fail_when_no_field_access() {
+  let client = build_client();
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD_NO_ACCESS_FIELD");
+  let result = client.delete_file(1, field_id, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_file_should_fail_when_no_app_access() {
+  let client = build_client();
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD_NO_ACCESS_APP");
+  let result = client.delete_file(1, field_id, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_file_should_fail_when_field_not_found() {
+  let client = build_client();
+  let result = client.delete_file(1, 0, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_file_should_fail_when_record_not_found() {
+  let client = build_client();
+  let field_id = required_env_i32("TEST_ATTACHMENT_FIELD");
+  let result = client.delete_file(0, field_id, 1).await;
+  assert!(result.is_err());
+}

tests/integration_lists.rs

@@ -0,0 +1,166 @@
+mod integration_common;
+
+use integration_common::*;
+use onspring::SaveListItemRequest;
+
+#[tokio::test]
+#[ignore]
+async fn save_list_item_should_add_item() {
+  let client = build_client();
+  let list_id = required_env_i32("TEST_LIST_ID");
+
+  let name = format!("added_list_value_{}", chrono::Utc::now().timestamp_millis());
+  let request = SaveListItemRequest {
+    id: None,
+    name,
+    numeric_value: Some(1.0),
+    color: Some("#000000".to_string()),
+  };
+
+  let response = client.save_list_item(list_id, request).await.unwrap();
+  let item_id = response.id;
+
+  // Cleanup
+  let _ = client.delete_list_item(list_id, item_id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn save_list_item_should_update_item() {
+  let client = build_client();
+  let list_id = required_env_i32("TEST_LIST_ID");
+
+  // Create
+  let name = format!("added_list_value_{}", chrono::Utc::now().timestamp_millis());
+  let request = SaveListItemRequest {
+    id: None,
+    name,
+    numeric_value: None,
+    color: None,
+  };
+  let created = client.save_list_item(list_id, request).await.unwrap();
+
+  // Update
+  let name = format!(
+    "updated_list_value_{}",
+    chrono::Utc::now().timestamp_millis()
+  );
+  let update_request = SaveListItemRequest {
+    id: Some(created.id),
+    name,
+    numeric_value: Some(1.0),
+    color: Some("#000000".to_string()),
+  };
+  let _response = client
+    .save_list_item(list_id, update_request)
+    .await
+    .unwrap();
+
+  // Cleanup
+  let _ = client.delete_list_item(list_id, created.id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn save_list_item_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let request = SaveListItemRequest {
+    id: None,
+    name: "test".to_string(),
+    numeric_value: Some(1.0),
+    color: Some("#000000".to_string()),
+  };
+  let result = client.save_list_item(1, request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn save_list_item_should_fail_when_list_not_found() {
+  let client = build_client();
+  let request = SaveListItemRequest {
+    id: None,
+    name: "test".to_string(),
+    numeric_value: Some(1.0),
+    color: Some("#000000".to_string()),
+  };
+  let result = client.save_list_item(0, request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn save_list_item_should_fail_when_item_not_found() {
+  let client = build_client();
+  let list_id = required_env_i32("TEST_LIST_ID");
+  let fake_uuid = uuid::Uuid::parse_str("3fa85f64-5717-4562-b3fc-2c963f66afa6").unwrap();
+
+  let request = SaveListItemRequest {
+    id: Some(fake_uuid),
+    name: "test".to_string(),
+    numeric_value: Some(1.0),
+    color: Some("#000000".to_string()),
+  };
+  let result = client.save_list_item(list_id, request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_list_item_should_succeed() {
+  let client = build_client();
+  let list_id = required_env_i32("TEST_LIST_ID");
+
+  // Create first
+  let name = format!("to_delete_{}", chrono::Utc::now().timestamp_millis());
+  let request = SaveListItemRequest {
+    id: None,
+    name,
+    numeric_value: Some(1.0),
+    color: Some("#000000".to_string()),
+  };
+  let created = client.save_list_item(list_id, request).await.unwrap();
+
+  // Delete
+  client.delete_list_item(list_id, created.id).await.unwrap();
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_list_item_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let fake_uuid = uuid::Uuid::parse_str("3fa85f64-5717-4562-b3fc-2c963f66afa6").unwrap();
+  let result = client.delete_list_item(1, fake_uuid).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_list_item_should_fail_when_no_access() {
+  let client = build_client();
+  let list_id = required_env_i32("TEST_LIST_ID_NO_ACCESS");
+  let item_id = required_env("TEST_LIST_ITEM_ID_NO_ACCESS");
+  let uuid = uuid::Uuid::parse_str(&item_id).unwrap();
+
+  let result = client.delete_list_item(list_id, uuid).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_list_item_should_fail_when_list_not_found() {
+  let client = build_client();
+  let fake_uuid = uuid::Uuid::parse_str("3fa85f64-5717-4562-b3fc-2c963f66afa6").unwrap();
+  let result = client.delete_list_item(0, fake_uuid).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_list_item_should_fail_when_item_not_found() {
+  let client = build_client();
+  let list_id = required_env_i32("TEST_LIST_ID");
+  let fake_uuid = uuid::Uuid::parse_str("3fa85f64-5717-4562-b3fc-2c963f66afa6").unwrap();
+  let result = client.delete_list_item(list_id, fake_uuid).await;
+  assert!(result.is_err());
+}

tests/integration_ping.rs

@@ -0,0 +1,18 @@
+mod integration_common;
+
+use integration_common::{build_client, build_client_with_key};
+
+#[tokio::test]
+#[ignore]
+async fn ping_should_succeed() {
+  let client = build_client();
+  client.ping().await.unwrap();
+}
+
+#[tokio::test]
+#[ignore]
+async fn ping_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.ping().await;
+  assert!(result.is_err());
+}

tests/integration_records.rs

@@ -0,0 +1,441 @@
+mod integration_common;
+
+use integration_common::*;
+use onspring::{
+  BatchDeleteRecordsRequest, BatchGetRecordsRequest, DataFormat, PagingRequest,
+  QueryRecordsRequest, SaveRecordRequest,
+};
+use std::collections::HashMap;
+
+#[tokio::test]
+#[ignore]
+async fn list_records_should_return_records() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let response = client.list_records(app_id, None, None, None).await.unwrap();
+
+  assert!(response.total_records.unwrap() > 0);
+  let items = response.items.unwrap();
+  assert!(!items.is_empty());
+
+  for record in &items {
+    assert_eq!(record.app_id, app_id);
+    assert!(record.record_id > 0);
+    assert!(record.field_data.is_some());
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_records_with_params_should_return_records() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let field_id = required_env_i32("TEST_TEXT_FIELD");
+  let paging = PagingRequest {
+    page_number: 1,
+    page_size: 1,
+  };
+
+  let response = client
+    .list_records(
+      app_id,
+      Some(paging),
+      Some(&[field_id]),
+      Some(DataFormat::Formatted),
+    )
+    .await
+    .unwrap();
+
+  assert_eq!(response.page_number.unwrap(), 1);
+  assert_eq!(response.page_size.unwrap(), 1);
+
+  for record in response.items.unwrap_or_default() {
+    assert_eq!(record.app_id, app_id);
+    assert!(record.field_data.is_some());
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_records_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.list_records(1, None, None, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_records_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let result = client.list_records(app_id, None, None, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_record_should_return_record() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let record_id = required_env_i32("TEST_SURVEY_RECORD_ID");
+
+  let record = client
+    .get_record(app_id, record_id, None, None)
+    .await
+    .unwrap();
+
+  assert_eq!(record.app_id, app_id);
+  assert_eq!(record.record_id, record_id);
+  assert!(record.field_data.is_some());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_record_with_params_should_return_record() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let record_id = required_env_i32("TEST_SURVEY_RECORD_ID");
+  let field_id = required_env_i32("TEST_TEXT_FIELD");
+
+  let record = client
+    .get_record(
+      app_id,
+      record_id,
+      Some(&[field_id]),
+      Some(DataFormat::Formatted),
+    )
+    .await
+    .unwrap();
+
+  assert_eq!(record.app_id, app_id);
+  assert_eq!(record.record_id, record_id);
+  assert!(record.field_data.is_some());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_record_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.get_record(1, 1, None, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_record_should_fail_when_not_found() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let result = client.get_record(app_id, 0, None, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn save_record_should_create_record() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let field_id = required_env("TEST_TEXT_FIELD");
+
+  let mut fields = HashMap::new();
+  fields.insert(field_id, serde_json::json!("integration test create"));
+
+  let request = SaveRecordRequest {
+    app_id,
+    record_id: None,
+    fields,
+  };
+
+  let response = client.save_record(request).await.unwrap();
+  assert!(response.id > 0);
+
+  // Cleanup
+  let _ = client.delete_record(app_id, response.id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn save_record_should_update_record() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let field_id = required_env("TEST_TEXT_FIELD");
+
+  // Create a record first
+  let mut fields = HashMap::new();
+  fields.insert(field_id.clone(), serde_json::json!("integration test"));
+  let create_request = SaveRecordRequest {
+    app_id,
+    record_id: None,
+    fields,
+  };
+  let created = client.save_record(create_request).await.unwrap();
+
+  // Update it
+  let mut fields = HashMap::new();
+  fields.insert(field_id, serde_json::json!("updated"));
+  let update_request = SaveRecordRequest {
+    app_id,
+    record_id: Some(created.id),
+    fields,
+  };
+  let response = client.save_record(update_request).await.unwrap();
+  assert_eq!(response.id, created.id);
+
+  // Cleanup
+  let _ = client.delete_record(app_id, created.id).await;
+}
+
+#[tokio::test]
+#[ignore]
+async fn save_record_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let request = SaveRecordRequest {
+    app_id: 0,
+    record_id: None,
+    fields: HashMap::new(),
+  };
+  let result = client.save_record(request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn save_record_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let request = SaveRecordRequest {
+    app_id,
+    record_id: None,
+    fields: HashMap::new(),
+  };
+  let result = client.save_record(request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_record_should_succeed() {
+  let record_id = add_record().await;
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+
+  client.delete_record(app_id, record_id).await.unwrap();
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_record_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.delete_record(1, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_record_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let result = client.delete_record(app_id, 1).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn delete_record_should_fail_when_not_found() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID");
+  let result = client.delete_record(app_id, 0).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_records_should_return_records() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let record_id = required_env_i32("TEST_SURVEY_RECORD_ID");
+
+  let request = BatchGetRecordsRequest {
+    app_id,
+    record_ids: vec![record_id],
+    field_ids: None,
+    data_format: None,
+  };
+
+  let response = client.batch_get_records(request).await.unwrap();
+  let items = response.items.unwrap();
+  assert!(!items.is_empty());
+
+  for record in &items {
+    assert_eq!(record.app_id, app_id);
+    assert!(record.field_data.is_some());
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_records_with_params_should_return_records() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let record_id = required_env_i32("TEST_SURVEY_RECORD_ID");
+  let field_id = required_env_i32("TEST_TEXT_FIELD");
+
+  let request = BatchGetRecordsRequest {
+    app_id,
+    record_ids: vec![record_id],
+    field_ids: Some(vec![field_id]),
+    data_format: Some(DataFormat::Formatted),
+  };
+
+  let response = client.batch_get_records(request).await.unwrap();
+  let items = response.items.unwrap();
+  assert!(!items.is_empty());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_records_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let request = BatchGetRecordsRequest {
+    app_id: 1,
+    record_ids: vec![1],
+    field_ids: None,
+    data_format: None,
+  };
+  let result = client.batch_get_records(request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_get_records_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let request = BatchGetRecordsRequest {
+    app_id,
+    record_ids: vec![1],
+    field_ids: None,
+    data_format: None,
+  };
+  let result = client.batch_get_records(request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn query_records_should_return_records() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let field_id = required_env_i32("TEST_SURVEY_AUTO_NUMBER_FIELD");
+
+  let filter = format!("{} gt 0", field_id);
+  let request = QueryRecordsRequest {
+    app_id,
+    filter,
+    field_ids: None,
+    data_format: None,
+  };
+
+  let response = client.query_records(request, None).await.unwrap();
+  assert!(response.total_records.unwrap() > 0);
+
+  for record in response.items.unwrap_or_default() {
+    assert_eq!(record.app_id, app_id);
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn query_records_with_params_should_return_records() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let field_id = required_env_i32("TEST_SURVEY_AUTO_NUMBER_FIELD");
+
+  let filter = format!("{} gt 0", field_id);
+  let paging = PagingRequest {
+    page_number: 1,
+    page_size: 1,
+  };
+  let request = QueryRecordsRequest {
+    app_id,
+    filter,
+    field_ids: Some(vec![field_id]),
+    data_format: Some(DataFormat::Formatted),
+  };
+
+  let response = client.query_records(request, Some(paging)).await.unwrap();
+  assert_eq!(response.page_size.unwrap(), 1);
+}
+
+#[tokio::test]
+#[ignore]
+async fn query_records_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let request = QueryRecordsRequest {
+    app_id: 1,
+    filter: String::new(),
+    field_ids: None,
+    data_format: None,
+  };
+  let result = client.query_records(request, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn query_records_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let field_id = required_env_i32("TEST_SURVEY_AUTO_NUMBER_FIELD");
+
+  let filter = format!("{} gt 0", field_id);
+  let request = QueryRecordsRequest {
+    app_id,
+    filter,
+    field_ids: None,
+    data_format: None,
+  };
+  let result = client.query_records(request, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_delete_records_should_succeed() {
+  let record_id1 = add_record().await;
+  let record_id2 = add_record().await;
+
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+
+  let request = BatchDeleteRecordsRequest {
+    app_id,
+    record_ids: vec![record_id1, record_id2],
+  };
+
+  client.batch_delete_records(request).await.unwrap();
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_delete_records_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let request = BatchDeleteRecordsRequest {
+    app_id: 1,
+    record_ids: vec![1],
+  };
+  let result = client.batch_delete_records(request).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn batch_delete_records_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let request = BatchDeleteRecordsRequest {
+    app_id,
+    record_ids: vec![1],
+  };
+  let result = client.batch_delete_records(request).await;
+  assert!(result.is_err());
+}

tests/integration_reports.rs

@@ -0,0 +1,124 @@
+mod integration_common;
+
+use integration_common::*;
+use onspring::{DataFormat, PagingRequest, ReportDataType};
+
+#[tokio::test]
+#[ignore]
+async fn get_report_should_return_report() {
+  let client = build_client();
+  let report_id = required_env_i32("TEST_REPORT");
+
+  let report = client.get_report(report_id, None, None).await.unwrap();
+
+  let columns = report.columns.unwrap();
+  assert!(!columns.is_empty());
+
+  let rows = report.rows.unwrap();
+  assert!(!rows.is_empty());
+
+  for row in &rows {
+    assert!(row.record_id.unwrap() > 0);
+    assert!(!row.cells.as_ref().unwrap().is_empty());
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_report_with_chart_data_should_return_data() {
+  let client = build_client();
+  let report_id = required_env_i32("TEST_REPORT_WITH_CHART_DATA");
+
+  let report = client
+    .get_report(
+      report_id,
+      Some(DataFormat::Raw),
+      Some(ReportDataType::ChartData),
+    )
+    .await
+    .unwrap();
+
+  assert!(!report.columns.unwrap().is_empty());
+  assert!(!report.rows.unwrap().is_empty());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_report_should_fail_for_chart_data_on_non_chart_report() {
+  let client = build_client();
+  let report_id = required_env_i32("TEST_REPORT");
+
+  let result = client
+    .get_report(
+      report_id,
+      Some(DataFormat::Raw),
+      Some(ReportDataType::ChartData),
+    )
+    .await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_report_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.get_report(1, None, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn get_report_should_fail_when_not_found() {
+  let client = build_client();
+  let result = client.get_report(0, None, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_reports_should_return_reports() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+
+  let response = client.list_reports(app_id, None).await.unwrap();
+
+  assert!(response.total_records.unwrap() > 0);
+  let items = response.items.unwrap();
+  assert!(!items.is_empty());
+
+  for report in &items {
+    assert!(report.id > 0);
+    assert!(report.app_id > 0);
+    assert!(report.name.is_some());
+  }
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_reports_should_fail_with_invalid_api_key() {
+  let client = build_client_with_key("invalid");
+  let result = client.list_reports(1, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_reports_should_fail_when_no_access() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_APP_ID_NO_ACCESS");
+  let result = client.list_reports(app_id, None).await;
+  assert!(result.is_err());
+}
+
+#[tokio::test]
+#[ignore]
+async fn list_reports_should_fail_with_invalid_page_size() {
+  let client = build_client();
+  let app_id = required_env_i32("TEST_SURVEY_ID");
+  let paging = PagingRequest {
+    page_number: 1,
+    page_size: 1001,
+  };
+  let result = client.list_reports(app_id, Some(paging)).await;
+  assert!(result.is_err());
+}

tests/test_data/test-attachment.txt

@@ -0,0 +1 @@
+This is a test attachment file for integration tests.