use async_trait::async_trait;
use chrono::Utc;
use dbnexus::sea_orm::{
ActiveModelTrait, ColumnTrait, ConnectionTrait, DatabaseBackend, EntityTrait, QueryFilter,
QueryOrder, QuerySelect, Set, Statement,
};
use dbnexus::DbPool;
use std::sync::Arc;
use crate::common::time_utils;
use crate::domain::models::{CreditsTransaction, CreditsTransactionType};
use crate::domain::repositories::credits_repository::{CreditsRepository, CreditsRepositoryError};
use crate::infrastructure::database::entities::{credits, credits_transactions};
use crate::infrastructure::persistence::mappers::CreditsTransactionMapper;
pub struct CreditsRepositoryImpl {
pool: Arc<DbPool>,
}
impl CreditsRepositoryImpl {
pub fn new(pool: Arc<DbPool>) -> Self {
Self { pool }
}
}
#[async_trait]
impl CreditsRepository for CreditsRepositoryImpl {
async fn get_balance(
&self,
team_id: crate::domain::id::Id,
) -> Result<i64, CreditsRepositoryError> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let conn = session
.connection()
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let credits = credits::Entity::find()
.filter(credits::Column::TeamId.eq(team_id))
.one(conn)
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
match credits {
Some(credits) => Ok(credits.balance),
None => {
self.initialize_team_credits(team_id, 0).await
}
}
}
async fn deduct_credits(
&self,
team_id: crate::domain::id::Id,
amount: i64,
transaction_type: CreditsTransactionType,
description: String,
reference_id: Option<crate::domain::id::Id>,
) -> Result<(), CreditsRepositoryError> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let conn = session
.connection()
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let stmt = Statement::from_sql_and_values(
DatabaseBackend::Postgres,
"SELECT deduct_credits_safe($1, $2, $3, $4, $5)",
[
team_id.into(),
amount.into(),
transaction_type.to_string().into(),
description.into(),
reference_id.map(uuid::Uuid::from).into(),
],
);
conn.execute_raw(stmt)
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
Ok(())
}
async fn has_deduction_for_task(
&self,
task_id: crate::domain::id::Id,
transaction_type: CreditsTransactionType,
) -> Result<bool, CreditsRepositoryError> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let conn = session
.connection()
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let existing = credits_transactions::Entity::find()
.filter(credits_transactions::Column::ReferenceId.eq(task_id))
.filter(credits_transactions::Column::TransactionType.eq(transaction_type.to_string()))
.filter(credits_transactions::Column::Amount.lt(0))
.one(conn)
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
Ok(existing.is_some())
}
async fn add_credits(
&self,
team_id: crate::domain::id::Id,
amount: i64,
transaction_type: CreditsTransactionType,
description: String,
reference_id: Option<crate::domain::id::Id>,
) -> Result<i64, CreditsRepositoryError> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let conn = session
.connection()
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let stmt = Statement::from_sql_and_values(
DatabaseBackend::Postgres,
"SELECT add_credits_safe($1, $2, $3, $4, $5) AS new_balance",
[
team_id.into(),
amount.into(),
transaction_type.to_string().into(),
description.into(),
reference_id.map(uuid::Uuid::from).into(),
],
);
let result = conn
.query_one_raw(stmt)
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
match result {
Some(row) => {
let new_balance: i64 = row
.try_get_by_index(0)
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
Ok(new_balance)
}
None => Err(CreditsRepositoryError::DatabaseError(
"add_credits_safe returned no row".to_string(),
)),
}
}
async fn get_transaction_history(
&self,
team_id: crate::domain::id::Id,
limit: Option<u32>,
) -> Result<Vec<CreditsTransaction>, CreditsRepositoryError> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let conn = session
.connection()
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let mut query = credits_transactions::Entity::find()
.filter(credits_transactions::Column::TeamId.eq(team_id))
.order_by_desc(credits_transactions::Column::CreatedAt);
if let Some(limit) = limit {
query = query.limit(limit as u64);
}
let transactions = query
.all(conn)
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
Ok(CreditsTransactionMapper::to_domain_list(transactions))
}
async fn initialize_team_credits(
&self,
team_id: crate::domain::id::Id,
initial_balance: i64,
) -> Result<i64, CreditsRepositoryError> {
let session = self
.pool
.get_session("admin")
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let conn = session
.connection()
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
let existing = credits::Entity::find()
.filter(credits::Column::TeamId.eq(team_id))
.one(conn)
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
if let Some(credits) = existing {
return Ok(credits.balance);
}
let credits = credits::ActiveModel {
id: Set(crate::domain::id::Id::generate().into()),
team_id: Set(team_id.into()),
balance: Set(initial_balance),
created_at: Set(Utc::now().with_timezone(&time_utils::UTC_OFFSET)),
updated_at: Set(Utc::now().with_timezone(&time_utils::UTC_OFFSET)),
};
credits
.insert(conn)
.await
.map_err(|e| CreditsRepositoryError::DatabaseError(e.to_string()))?;
Ok(initial_balance)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::test_helpers::create_test_db_pool;
#[test]
fn test_new_creates_repository_instance() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let repo = CreditsRepositoryImpl::new(pool);
let _ = repo;
}
#[tokio::test]
async fn test_get_balance_returns_zero_for_unknown_team() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let result = repo.get_balance(team_id).await;
assert!(result.is_ok(), "get_balance failed: {:?}", result.err());
assert_eq!(result.unwrap(), 0, "auto-initialized balance should be 0");
let result2 = repo.get_balance(team_id).await;
assert!(
result2.is_ok(),
"second get_balance failed: {:?}",
result2.err()
);
assert_eq!(result2.unwrap(), 0);
}
#[tokio::test]
async fn test_deduct_credits_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
repo.initialize_team_credits(team_id, 200)
.await
.expect("initialize failed");
let result = repo
.deduct_credits(
team_id,
100,
CreditsTransactionType::Search,
"test deduct".to_string(),
None,
)
.await;
assert!(result.is_ok(), "deduct_credits failed: {:?}", result.err());
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 100, "balance should be 200 - 100 = 100");
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1, "should have 1 transaction");
assert_eq!(history[0].amount, -100, "transaction amount should be -100");
}
#[tokio::test]
async fn test_add_credits_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let result = repo
.add_credits(
team_id,
100,
CreditsTransactionType::Search,
"test add".to_string(),
None,
)
.await;
assert!(result.is_ok(), "add_credits failed: {:?}", result.err());
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 100, "balance should be 100 after adding 100");
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1, "should have 1 transaction");
assert_eq!(history[0].amount, 100, "transaction amount should be 100");
}
#[tokio::test]
async fn test_get_transaction_history_returns_empty_for_unknown_team() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let result = repo
.get_transaction_history(crate::domain::id::Id::generate(), Some(10))
.await;
assert!(
result.is_ok(),
"get_transaction_history failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown team should return empty history"
);
}
#[tokio::test]
async fn test_initialize_team_credits_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let result = repo.initialize_team_credits(team_id, 0).await;
assert!(
result.is_ok(),
"initialize_team_credits failed: {:?}",
result.err()
);
assert_eq!(result.unwrap(), 0, "should return the initial balance");
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 0);
let result2 = repo.initialize_team_credits(team_id, 500).await;
assert!(
result2.is_ok(),
"second initialize failed: {:?}",
result2.err()
);
assert_eq!(
result2.unwrap(),
0,
"should return existing balance, not new"
);
}
#[test]
fn test_error_database_error_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = CreditsRepositoryError::DatabaseError("conn refused".to_string());
assert!(err.to_string().contains("Database error"));
assert!(err.to_string().contains("conn refused"));
}
#[test]
fn test_error_insufficient_credits_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = CreditsRepositoryError::InsufficientCredits {
available: 50,
required: 100,
};
assert!(err.to_string().contains("Insufficient credits"));
assert!(err.to_string().contains("50"));
assert!(err.to_string().contains("100"));
}
#[test]
fn test_error_credits_not_found_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let team_id = crate::domain::id::Id::generate();
let err = CreditsRepositoryError::CreditsNotFound(team_id);
assert!(err.to_string().contains("Credits not found for team"));
assert!(err.to_string().contains(&team_id.to_string()));
}
#[tokio::test]
async fn test_get_transaction_history_with_no_limit() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let result = repo
.get_transaction_history(crate::domain::id::Id::generate(), None)
.await;
assert!(
result.is_ok(),
"get_transaction_history failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown team should return empty"
);
}
#[tokio::test]
async fn test_get_transaction_history_with_zero_limit() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let result = repo
.get_transaction_history(crate::domain::id::Id::generate(), Some(0))
.await;
assert!(
result.is_ok(),
"get_transaction_history failed: {:?}",
result.err()
);
assert!(result.unwrap().is_empty(), "limit=0 should return empty");
}
#[tokio::test]
async fn test_get_transaction_history_with_large_limit() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let result = repo
.get_transaction_history(crate::domain::id::Id::generate(), Some(u32::MAX))
.await;
assert!(
result.is_ok(),
"get_transaction_history failed: {:?}",
result.err()
);
assert!(
result.unwrap().is_empty(),
"unknown team should return empty"
);
}
#[tokio::test]
async fn test_get_balance_with_nil_uuid() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let result = repo.get_balance(crate::domain::id::Id::nil()).await;
assert!(
result.is_ok(),
"get_balance with nil uuid failed: {:?}",
result.err()
);
}
#[tokio::test]
async fn test_deduct_credits_with_reference_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
repo.initialize_team_credits(team_id, 200)
.await
.expect("initialize failed");
let reference_id = crate::domain::id::Id::generate();
let result = repo
.deduct_credits(
team_id,
50,
CreditsTransactionType::Scrape,
"deduct with ref".to_string(),
Some(reference_id),
)
.await;
assert!(result.is_ok(), "deduct_credits failed: {:?}", result.err());
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 150, "balance should be 200 - 50 = 150");
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1);
assert_eq!(history[0].reference_id, Some(reference_id));
}
#[tokio::test]
async fn test_deduct_credits_with_zero_amount() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
repo.initialize_team_credits(team_id, 100)
.await
.expect("initialize failed");
let result = repo
.deduct_credits(
team_id,
0,
CreditsTransactionType::Search,
"zero deduct".to_string(),
None,
)
.await;
assert!(
result.is_ok(),
"deduct_credits with 0 failed: {:?}",
result.err()
);
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 100, "balance should remain 100");
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1);
assert_eq!(history[0].amount, 0);
}
#[tokio::test]
async fn test_deduct_credits_with_description_containing_quotes() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
repo.initialize_team_credits(team_id, 100)
.await
.expect("initialize failed");
let description = "it's a 'test' description".to_string();
let result = repo
.deduct_credits(
team_id,
10,
CreditsTransactionType::Extract,
description.clone(),
None,
)
.await;
assert!(result.is_ok(), "deduct_credits failed: {:?}", result.err());
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1);
assert_eq!(history[0].description, description);
}
#[tokio::test]
async fn test_add_credits_with_reference_id() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let reference_id = crate::domain::id::Id::generate();
let result = repo
.add_credits(
team_id,
200,
CreditsTransactionType::Subscription,
"add with ref".to_string(),
Some(reference_id),
)
.await;
assert!(result.is_ok(), "add_credits failed: {:?}", result.err());
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 200, "balance should be 200");
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1);
assert_eq!(history[0].reference_id, Some(reference_id));
}
#[tokio::test]
async fn test_add_credits_with_zero_amount() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let result = repo
.add_credits(
team_id,
0,
CreditsTransactionType::Refund,
"zero add".to_string(),
None,
)
.await;
assert!(
result.is_ok(),
"add_credits with 0 failed: {:?}",
result.err()
);
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 0, "balance should be 0 after adding 0");
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1);
assert_eq!(history[0].amount, 0);
}
#[tokio::test]
async fn test_add_credits_with_description_containing_quotes() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let description = "it's a 'test'".to_string();
let result = repo
.add_credits(
team_id,
100,
CreditsTransactionType::ManualAdjustment,
description.clone(),
None,
)
.await;
assert!(result.is_ok(), "add_credits failed: {:?}", result.err());
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1);
assert_eq!(history[0].description, description);
}
#[tokio::test]
async fn test_initialize_team_credits_with_non_zero_balance() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let result = repo.initialize_team_credits(team_id, 1000).await;
assert!(result.is_ok(), "initialize failed: {:?}", result.err());
assert_eq!(result.unwrap(), 1000, "should return the initial balance");
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 1000);
}
#[tokio::test]
async fn test_initialize_team_credits_with_negative_balance() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let result = repo.initialize_team_credits(team_id, -500).await;
assert!(
result.is_ok(),
"initialize with negative failed: {:?}",
result.err()
);
assert_eq!(result.unwrap(), -500, "should return the negative balance");
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, -500);
}
#[tokio::test]
async fn test_initialize_team_credits_with_nil_uuid() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let result = repo
.initialize_team_credits(crate::domain::id::Id::nil(), 0)
.await;
assert!(
result.is_ok(),
"initialize with nil uuid failed: {:?}",
result.err()
);
}
#[tokio::test]
async fn test_deduct_credits_with_crawl_type() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
repo.initialize_team_credits(team_id, 100)
.await
.expect("initialize failed");
let result = repo
.deduct_credits(
team_id,
5,
CreditsTransactionType::Crawl,
"crawl deduct".to_string(),
None,
)
.await;
assert!(
result.is_ok(),
"deduct_credits with Crawl failed: {:?}",
result.err()
);
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 95, "balance should be 100 - 5 = 95");
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1);
assert_eq!(history[0].transaction_type, CreditsTransactionType::Crawl);
}
#[tokio::test]
async fn test_add_credits_with_extract_type() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let repo = CreditsRepositoryImpl::new(create_test_db_pool());
let team_id = crate::domain::id::Id::generate();
let result = repo
.add_credits(
team_id,
50,
CreditsTransactionType::Extract,
"extract add".to_string(),
None,
)
.await;
assert!(
result.is_ok(),
"add_credits with Extract failed: {:?}",
result.err()
);
let balance = repo.get_balance(team_id).await.expect("get_balance failed");
assert_eq!(balance, 50, "balance should be 50");
let history = repo
.get_transaction_history(team_id, Some(10))
.await
.expect("get_transaction_history failed");
assert_eq!(history.len(), 1);
assert_eq!(history[0].transaction_type, CreditsTransactionType::Extract);
}
#[test]
fn test_credits_transaction_type_search_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", CreditsTransactionType::Search), "search");
}
#[test]
fn test_credits_transaction_type_scrape_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", CreditsTransactionType::Scrape), "scrape");
}
#[test]
fn test_credits_transaction_type_extract_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", CreditsTransactionType::Extract), "extract");
}
#[test]
fn test_credits_transaction_type_crawl_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", CreditsTransactionType::Crawl), "crawl");
}
#[test]
fn test_credits_transaction_type_manual_adjustment_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(
format!("{}", CreditsTransactionType::ManualAdjustment),
"manual_adjustment"
);
}
#[test]
fn test_credits_transaction_type_subscription_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(
format!("{}", CreditsTransactionType::Subscription),
"subscription"
);
}
#[test]
fn test_credits_transaction_type_refund_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert_eq!(format!("{}", CreditsTransactionType::Refund), "refund");
}
#[test]
fn test_error_database_error_with_empty_message() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = CreditsRepositoryError::DatabaseError("".to_string());
assert_eq!(format!("{}", err), "Database error: ");
}
#[test]
fn test_error_database_error_with_long_message() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let long_msg = "x".repeat(1000);
let err = CreditsRepositoryError::DatabaseError(long_msg.clone());
let msg = format!("{}", err);
assert!(msg.contains(&long_msg));
}
#[test]
fn test_error_insufficient_credits_with_zero_values() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = CreditsRepositoryError::InsufficientCredits {
available: 0,
required: 0,
};
let msg = format!("{}", err);
assert!(msg.contains("available 0"));
assert!(msg.contains("required 0"));
}
#[test]
fn test_error_insufficient_credits_with_large_values() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = CreditsRepositoryError::InsufficientCredits {
available: i64::MAX,
required: i64::MAX,
};
let msg = format!("{}", err);
assert!(msg.contains(&i64::MAX.to_string()));
}
#[test]
fn test_error_credits_not_found_with_nil_uuid() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = CreditsRepositoryError::CreditsNotFound(crate::domain::id::Id::nil());
let msg = format!("{}", err);
assert!(msg.contains("00000000-0000-0000-0000-000000000000"));
}
}