use dbnexus::sea_orm::{ConnectionTrait, DbErr};
use dbnexus::{DbPool, Session};
use log::{debug, error, info, warn};
use parking_lot::RwLock;
use std::collections::VecDeque;
use std::sync::Arc;
use thiserror::Error;
#[derive(Error, Debug)]
pub enum TransactionError {
#[error("Failed to begin transaction: {0}")]
BeginFailed(String),
#[error("Failed to commit transaction: {0}")]
CommitFailed(String),
#[error("Failed to rollback transaction: {0}")]
RollbackFailed(String),
#[error("Failed to create savepoint '{name}': {message}")]
SavepointFailed { name: String, message: String },
#[error("Failed to release savepoint '{name}': {message}")]
ReleaseSavepointFailed { name: String, message: String },
#[error("Failed to rollback to savepoint '{name}': {message}")]
RollbackToSavepointFailed { name: String, message: String },
#[error("No active transaction")]
NoActiveTransaction,
#[error("Transaction already active")]
TransactionAlreadyActive,
#[error("Invalid savepoint name: {0}")]
InvalidSavepointName(String),
#[error("Savepoint not found: {0}")]
SavepointNotFound(String),
#[error("Database error: {0}")]
DatabaseError(String),
}
impl From<DbErr> for TransactionError {
fn from(err: DbErr) -> Self {
TransactionError::DatabaseError(err.to_string())
}
}
#[derive(Debug, Clone, Copy, Default)]
pub enum TransactionIsolation {
ReadUncommitted,
#[default]
ReadCommitted,
RepeatableRead,
Serializable,
}
#[derive(Debug, Clone, Copy, Default)]
pub enum TransactionAccess {
#[default]
ReadWrite,
ReadOnly,
}
#[derive(Debug, Clone)]
pub struct TransactionConfig {
pub isolation_level: TransactionIsolation,
pub access_mode: TransactionAccess,
pub enable_savepoints: bool,
pub role: String,
}
impl Default for TransactionConfig {
fn default() -> Self {
Self {
isolation_level: TransactionIsolation::ReadCommitted,
access_mode: TransactionAccess::ReadWrite,
enable_savepoints: true,
role: "admin".to_string(),
}
}
}
#[derive(Debug, Clone)]
struct Savepoint {
id: crate::domain::id::Id,
name: String,
}
struct ActiveTransaction {
session: Session,
config: TransactionConfig,
savepoints: VecDeque<Savepoint>,
finished: bool,
}
pub struct TransactionManager {
pool: Arc<DbPool>,
active_transaction: RwLock<Option<ActiveTransaction>>,
default_config: TransactionConfig,
}
pub(crate) fn validate_savepoint_name(name: &str) -> Result<(), TransactionError> {
if name.is_empty() {
return Err(TransactionError::InvalidSavepointName(
"Savepoint name cannot be empty".to_string(),
));
}
if name.len() > 63 {
return Err(TransactionError::InvalidSavepointName(
"Savepoint name too long (max 63 characters)".to_string(),
));
}
let valid = name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_');
if !valid {
return Err(TransactionError::InvalidSavepointName(
"Savepoint name must contain only ASCII alphanumeric characters and underscores"
.to_string(),
));
}
Ok(())
}
impl TransactionManager {
pub fn new(pool: Arc<DbPool>) -> Self {
Self {
pool,
active_transaction: RwLock::new(None),
default_config: TransactionConfig::default(),
}
}
pub fn with_config(pool: Arc<DbPool>, config: TransactionConfig) -> Self {
Self {
pool,
active_transaction: RwLock::new(None),
default_config: config,
}
}
pub async fn begin(&self) -> Result<(), TransactionError> {
debug!("transaction_begin");
self.begin_with_config(self.default_config.clone()).await
}
pub async fn begin_with_config(
&self,
config: TransactionConfig,
) -> Result<(), TransactionError> {
{
let active_tx = self.active_transaction.read();
if active_tx.is_some() {
return Err(TransactionError::TransactionAlreadyActive);
}
}
let session = self.pool.get_session(&config.role).await.map_err(|e| {
error!("Failed to get session: {}", e);
TransactionError::BeginFailed(e.to_string())
})?;
session.begin_transaction().await.map_err(|e| {
error!("Failed to begin transaction: {}", e);
TransactionError::BeginFailed(e.to_string())
})?;
debug!(
"Transaction started with role: {}, isolation: {:?}, access: {:?}",
config.role, config.isolation_level, config.access_mode
);
let mut active_tx = self.active_transaction.write();
*active_tx = Some(ActiveTransaction {
session,
config,
savepoints: VecDeque::new(),
finished: false,
});
Ok(())
}
#[allow(clippy::await_holding_lock)]
pub async fn commit(&self) -> Result<(), TransactionError> {
let mut active_tx = self.active_transaction.write();
let tx_state = active_tx
.as_mut()
.ok_or(TransactionError::NoActiveTransaction)?;
if tx_state.finished {
return Err(TransactionError::NoActiveTransaction);
}
tx_state.finished = true;
tx_state.session.commit().await.map_err(|e| {
error!("Failed to commit transaction: {}", e);
TransactionError::CommitFailed(e.to_string())
})?;
*active_tx = None;
info!("Transaction committed successfully");
Ok(())
}
#[allow(clippy::await_holding_lock)]
pub async fn rollback(&self) -> Result<(), TransactionError> {
let mut active_tx = self.active_transaction.write();
let tx_state = active_tx
.as_mut()
.ok_or(TransactionError::NoActiveTransaction)?;
if tx_state.finished {
return Err(TransactionError::NoActiveTransaction);
}
tx_state.finished = true;
tx_state.session.rollback().await.map_err(|e| {
error!("Failed to rollback transaction: {}", e);
TransactionError::RollbackFailed(e.to_string())
})?;
*active_tx = None;
info!("Transaction rolled back successfully");
Ok(())
}
#[allow(clippy::await_holding_lock)]
pub async fn savepoint(&self, name: &str) -> Result<crate::domain::id::Id, TransactionError> {
validate_savepoint_name(name)?;
let mut active_tx = self.active_transaction.write();
let tx_state = active_tx
.as_mut()
.ok_or(TransactionError::NoActiveTransaction)?;
if !tx_state.config.enable_savepoints {
return Err(TransactionError::SavepointFailed {
name: name.to_string(),
message: "Savepoints are disabled for this transaction".to_string(),
});
}
if tx_state.finished {
return Err(TransactionError::NoActiveTransaction);
}
if tx_state.savepoints.iter().any(|sp| sp.name == name) {
return Err(TransactionError::SavepointFailed {
name: name.to_string(),
message: "Savepoint with this name already exists".to_string(),
});
}
let sql = format!("SAVEPOINT {}", name);
let conn = tx_state.session.connection().map_err(|e| {
error!("Failed to get connection for savepoint '{}': {}", name, e);
TransactionError::SavepointFailed {
name: name.to_string(),
message: e.to_string(),
}
})?;
conn.execute_unprepared(&sql).await.map_err(|e| {
error!("Failed to create savepoint '{}': {}", name, e);
TransactionError::SavepointFailed {
name: name.to_string(),
message: e.to_string(),
}
})?;
let savepoint = Savepoint {
id: crate::domain::id::Id::generate(),
name: name.to_string(),
};
let savepoint_id = savepoint.id;
tx_state.savepoints.push_back(savepoint);
debug!("Savepoint '{}' created with id: {}", name, savepoint_id);
Ok(savepoint_id)
}
#[allow(clippy::await_holding_lock)]
pub async fn release_savepoint(&self, name: &str) -> Result<(), TransactionError> {
validate_savepoint_name(name)?;
let mut active_tx = self.active_transaction.write();
let tx_state = active_tx
.as_mut()
.ok_or(TransactionError::NoActiveTransaction)?;
if tx_state.finished {
return Err(TransactionError::NoActiveTransaction);
}
let position = tx_state
.savepoints
.iter()
.position(|sp| sp.name == name)
.ok_or_else(|| TransactionError::SavepointNotFound(name.to_string()))?;
let sql = format!("RELEASE SAVEPOINT {}", name);
let conn = tx_state.session.connection().map_err(|e| {
error!(
"Failed to get connection for release_savepoint '{}': {}",
name, e
);
TransactionError::ReleaseSavepointFailed {
name: name.to_string(),
message: e.to_string(),
}
})?;
conn.execute_unprepared(&sql).await.map_err(|e| {
error!("Failed to release savepoint '{}': {}", name, e);
TransactionError::ReleaseSavepointFailed {
name: name.to_string(),
message: e.to_string(),
}
})?;
tx_state.savepoints.remove(position);
debug!("Savepoint '{}' released", name);
Ok(())
}
#[allow(clippy::await_holding_lock)]
pub async fn rollback_to_savepoint(&self, name: &str) -> Result<(), TransactionError> {
validate_savepoint_name(name)?;
let mut active_tx = self.active_transaction.write();
let tx_state = active_tx
.as_mut()
.ok_or(TransactionError::NoActiveTransaction)?;
if tx_state.finished {
return Err(TransactionError::NoActiveTransaction);
}
if !tx_state.savepoints.iter().any(|sp| sp.name == name) {
return Err(TransactionError::SavepointNotFound(name.to_string()));
}
let sql = format!("ROLLBACK TO SAVEPOINT {}", name);
let conn = tx_state.session.connection().map_err(|e| {
error!(
"Failed to get connection for rollback_to_savepoint '{}': {}",
name, e
);
TransactionError::RollbackToSavepointFailed {
name: name.to_string(),
message: e.to_string(),
}
})?;
conn.execute_unprepared(&sql).await.map_err(|e| {
error!("Failed to rollback to savepoint '{}': {}", name, e);
TransactionError::RollbackToSavepointFailed {
name: name.to_string(),
message: e.to_string(),
}
})?;
let position = tx_state
.savepoints
.iter()
.position(|sp| sp.name == name)
.expect("Savepoint existence verified above, position must exist");
tx_state.savepoints.truncate(position + 1);
debug!("Rolled back to savepoint '{}'", name);
Ok(())
}
pub fn is_active(&self) -> bool {
let active_tx = self.active_transaction.read();
active_tx.as_ref().map(|tx| !tx.finished).unwrap_or(false)
}
pub fn has_transaction(&self) -> bool {
let active_tx = self.active_transaction.read();
active_tx.as_ref().filter(|tx| !tx.finished).is_some()
}
pub fn savepoint_count(&self) -> usize {
let active_tx = self.active_transaction.read();
active_tx
.as_ref()
.map(|tx| tx.savepoints.len())
.unwrap_or(0)
}
}
impl Drop for TransactionManager {
fn drop(&mut self) {
if let Some(active_tx) = self.active_transaction.read().as_ref() {
if !active_tx.finished {
warn!("TransactionManager dropped with active transaction - transaction will be rolled back");
}
}
}
}
pub struct TransactionGuard<'a> {
manager: &'a TransactionManager,
committed: bool,
}
impl<'a> TransactionGuard<'a> {
pub fn new(manager: &'a TransactionManager) -> Self {
Self {
manager,
committed: false,
}
}
pub async fn commit(mut self) -> Result<(), TransactionError> {
self.manager.commit().await?;
self.committed = true;
Ok(())
}
pub async fn rollback(mut self) -> Result<(), TransactionError> {
self.manager.rollback().await?;
self.committed = true;
Ok(())
}
}
impl<'a> Drop for TransactionGuard<'a> {
fn drop(&mut self) {
if !self.committed && self.manager.is_active() {
warn!("TransactionGuard dropped without commit - transaction should be rolled back");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::common::test_helpers::create_test_db_pool;
#[test]
fn test_transaction_config_default() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let config = TransactionConfig::default();
assert!(matches!(
config.isolation_level,
TransactionIsolation::ReadCommitted
));
assert!(matches!(config.access_mode, TransactionAccess::ReadWrite));
assert!(config.enable_savepoints);
assert_eq!(config.role, "admin");
}
#[test]
fn test_transaction_config_custom() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let config = TransactionConfig {
isolation_level: TransactionIsolation::Serializable,
access_mode: TransactionAccess::ReadOnly,
enable_savepoints: false,
role: "readonly".to_string(),
};
assert!(matches!(
config.isolation_level,
TransactionIsolation::Serializable
));
assert!(matches!(config.access_mode, TransactionAccess::ReadOnly));
assert!(!config.enable_savepoints);
assert_eq!(config.role, "readonly");
}
#[test]
fn test_transaction_isolation_variants() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _ = TransactionIsolation::ReadUncommitted;
let _ = TransactionIsolation::ReadCommitted;
let _ = TransactionIsolation::RepeatableRead;
let _ = TransactionIsolation::Serializable;
}
#[test]
fn test_transaction_access_mode_variants() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let _ = TransactionAccess::ReadWrite;
let _ = TransactionAccess::ReadOnly;
}
#[test]
fn test_transaction_error_display() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::BeginFailed("test".to_string());
assert!(err.to_string().contains("test"));
let err = TransactionError::CommitFailed("test".to_string());
assert!(err.to_string().contains("test"));
let err = TransactionError::RollbackFailed("test".to_string());
assert!(err.to_string().contains("test"));
let err = TransactionError::NoActiveTransaction;
assert!(err.to_string().contains("No active transaction"));
let err = TransactionError::TransactionAlreadyActive;
assert!(err.to_string().contains("already active"));
let err = TransactionError::InvalidSavepointName("test".to_string());
assert!(err.to_string().contains("Invalid"));
let err = TransactionError::SavepointNotFound("test".to_string());
assert!(err.to_string().contains("not found"));
let err = TransactionError::SavepointFailed {
name: "sp1".to_string(),
message: "error".to_string(),
};
assert!(err.to_string().contains("sp1"));
assert!(err.to_string().contains("error"));
let err = TransactionError::ReleaseSavepointFailed {
name: "sp1".to_string(),
message: "error".to_string(),
};
assert!(err.to_string().contains("sp1"));
let err = TransactionError::RollbackToSavepointFailed {
name: "sp1".to_string(),
message: "error".to_string(),
};
assert!(err.to_string().contains("sp1"));
let err = TransactionError::DatabaseError("db error".to_string());
assert!(err.to_string().contains("db error"));
}
#[test]
fn test_from_dberr_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::Custom("custom db error".to_string());
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("custom db error"));
}
#[test]
fn test_new_creates_manager_without_active_transaction() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
assert!(!manager.is_active());
assert!(!manager.has_transaction());
assert_eq!(manager.savepoint_count(), 0);
}
#[test]
fn test_with_config_creates_manager_with_custom_config() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let config = TransactionConfig {
isolation_level: TransactionIsolation::Serializable,
access_mode: TransactionAccess::ReadOnly,
enable_savepoints: false,
role: "readonly".to_string(),
};
let manager = TransactionManager::with_config(pool, config);
assert!(!manager.is_active());
assert!(!manager.has_transaction());
assert_eq!(manager.savepoint_count(), 0);
}
#[test]
fn test_is_active_false_when_no_transaction() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
assert!(!manager.is_active());
}
#[test]
fn test_has_transaction_false_when_no_transaction() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
assert!(!manager.has_transaction());
}
#[test]
fn test_savepoint_count_zero_when_no_transaction() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
assert_eq!(manager.savepoint_count(), 0);
}
#[test]
fn test_validate_savepoint_name_empty_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("");
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
assert!(result.unwrap_err().to_string().contains("empty"));
}
#[test]
fn test_validate_savepoint_name_too_long_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let long_name = "a".repeat(64);
let result = validate_savepoint_name(&long_name);
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
assert!(result.unwrap_err().to_string().contains("too long"));
}
#[test]
fn test_validate_savepoint_name_max_length_accepted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let max_name = "a".repeat(63);
let result = validate_savepoint_name(&max_name);
assert!(result.is_ok(), "expected Ok for 63-char name");
}
#[test]
fn test_validate_savepoint_name_one_over_max_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let name = "a".repeat(64);
let result = validate_savepoint_name(&name);
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
assert!(result.unwrap_err().to_string().contains("too long"));
}
#[test]
fn test_validate_savepoint_name_invalid_chars_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("invalid-name");
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
assert!(result.unwrap_err().to_string().contains("alphanumeric"));
}
#[test]
fn test_validate_savepoint_name_with_space_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("invalid name");
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[test]
fn test_validate_savepoint_name_with_special_chars_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
for invalid_name in &["sp@1", "sp.1", "sp/1", "sp-1", "sp!1", "sp#1"] {
let result = validate_savepoint_name(invalid_name);
assert!(
matches!(result, Err(TransactionError::InvalidSavepointName(_))),
"Expected InvalidSavepointName for '{}'",
invalid_name
);
}
}
#[test]
fn test_validate_savepoint_name_valid_names_accepted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
for valid_name in &["sp1", "savepoint_1", "SAVEPOINT_1", "sp123", "_sp"] {
let result = validate_savepoint_name(valid_name);
assert!(
result.is_ok(),
"Expected Ok for valid name '{}', got {:?}",
valid_name,
result.err()
);
}
}
#[test]
fn test_validate_savepoint_name_single_char_accepted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("a");
assert!(result.is_ok());
}
#[test]
fn test_validate_savepoint_name_single_underscore_accepted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("_");
assert!(result.is_ok());
}
#[test]
fn test_validate_savepoint_name_digits_only_accepted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("12345");
assert!(result.is_ok());
}
#[test]
fn test_validate_savepoint_name_unicode_alphanumeric_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("测试点");
assert!(result.is_err());
}
#[test]
fn test_validate_savepoint_name_tab_character_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("sp\t1");
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[test]
fn test_validate_savepoint_name_newline_character_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("sp\n1");
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[test]
fn test_validate_savepoint_name_emoji_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("sp🎉");
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[test]
fn test_validate_savepoint_name_at_max_boundary_accepted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let name = "a".repeat(63);
let result = validate_savepoint_name(&name);
assert!(result.is_ok());
}
#[test]
fn test_validate_savepoint_name_returns_unit_ok_for_valid_input() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let result = validate_savepoint_name("valid_sp");
assert!(result.is_ok());
assert!(matches!(result, Ok(())));
}
#[tokio::test]
async fn test_savepoint_empty_name_rejected_before_active_check() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
let err = result.unwrap_err();
assert!(err.to_string().contains("empty"));
}
#[tokio::test]
async fn test_savepoint_name_too_long_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let long_name = "a".repeat(64);
let result = manager.savepoint(&long_name).await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
let err = result.unwrap_err();
assert!(err.to_string().contains("too long"));
}
#[tokio::test]
async fn test_savepoint_name_max_length_accepted() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let max_name = "a".repeat(63);
let result = manager.savepoint(&max_name).await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_savepoint_name_invalid_chars_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("invalid-name").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
let err = result.unwrap_err();
assert!(err.to_string().contains("alphanumeric"));
}
#[tokio::test]
async fn test_savepoint_name_with_space_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("invalid name").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_savepoint_name_with_special_chars_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
for invalid_name in &["sp@1", "sp.1", "sp/1", "sp-1", "sp!1", "sp#1"] {
let result = manager.savepoint(invalid_name).await;
assert!(
matches!(result, Err(TransactionError::InvalidSavepointName(_))),
"Expected InvalidSavepointName for '{}'",
invalid_name
);
}
}
#[tokio::test]
async fn test_savepoint_valid_name_passes_validation_but_no_tx() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
for valid_name in &["sp1", "savepoint_1", "SAVEPOINT_1", "sp123", "_sp"] {
let result = manager.savepoint(valid_name).await;
assert!(
matches!(result, Err(TransactionError::NoActiveTransaction)),
"Expected NoActiveTransaction for valid name '{}'",
valid_name
);
}
}
#[tokio::test]
async fn test_release_savepoint_empty_name_rejected_before_active_check() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.release_savepoint("").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_release_savepoint_invalid_name_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.release_savepoint("invalid-name").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_release_savepoint_valid_name_no_tx_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.release_savepoint("valid_sp").await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_rollback_to_savepoint_empty_name_rejected_before_active_check() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.rollback_to_savepoint("").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_rollback_to_savepoint_invalid_name_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.rollback_to_savepoint("invalid-name").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_rollback_to_savepoint_valid_name_no_tx_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.rollback_to_savepoint("valid_sp").await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_begin_succeeds_with_real_db() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.begin().await;
assert!(
result.is_ok(),
"expected Ok with real DB connection, got {:?}",
result.err()
);
assert!(manager.is_active());
let _ = manager.rollback().await;
}
#[tokio::test]
async fn test_begin_with_config_succeeds_with_real_db() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let config = TransactionConfig {
isolation_level: TransactionIsolation::Serializable,
access_mode: TransactionAccess::ReadOnly,
enable_savepoints: false,
role: "readonly".to_string(),
};
let manager = TransactionManager::with_config(pool, config);
let result = manager
.begin_with_config(TransactionConfig::default())
.await;
assert!(
result.is_ok(),
"expected Ok with real DB connection, got {:?}",
result.err()
);
assert!(manager.is_active());
let _ = manager.rollback().await;
}
#[tokio::test]
async fn test_commit_without_active_transaction_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.commit().await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_rollback_without_active_transaction_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.rollback().await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[test]
fn test_guard_new_creates_uncommitted_guard() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let _guard = TransactionGuard::new(&manager);
assert!(!manager.is_active());
}
#[tokio::test]
async fn test_guard_commit_without_active_tx_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let guard = TransactionGuard::new(&manager);
let result = guard.commit().await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_guard_rollback_without_active_tx_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let guard = TransactionGuard::new(&manager);
let result = guard.rollback().await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[test]
fn test_guard_drop_without_active_tx_does_not_panic() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
{
let _guard = TransactionGuard::new(&manager);
}
assert!(!manager.is_active());
}
#[test]
fn test_drop_without_active_transaction_does_not_panic() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
drop(manager);
}
#[test]
fn test_manager_can_be_cloned_via_arc() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let arc_manager = Arc::new(manager);
assert!(!arc_manager.is_active());
assert_eq!(arc_manager.savepoint_count(), 0);
}
#[test]
fn test_from_dberr_record_not_found_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::RecordNotFound("task 42".to_string());
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("task 42"));
}
#[test]
fn test_from_dberr_connection_acquire_timeout_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::ConnectionAcquire(dbnexus::sea_orm::ConnAcquireErr::Timeout);
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
}
#[test]
fn test_from_dberr_connection_acquire_closed_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::ConnectionAcquire(dbnexus::sea_orm::ConnAcquireErr::ConnectionClosed);
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
}
#[test]
fn test_from_dberr_record_not_inserted_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::RecordNotInserted;
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
}
#[test]
fn test_from_dberr_query_runtime_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::Query(dbnexus::sea_orm::RuntimeErr::Internal(
"syntax error".to_string(),
));
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("syntax error"));
}
#[test]
fn test_from_dberr_query_sqlx_error_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let inner = dbnexus::sea_orm::sqlx::Error::RowNotFound;
let db_err = DbErr::Query(dbnexus::sea_orm::RuntimeErr::SqlxError(
std::sync::Arc::new(inner),
));
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
}
#[test]
fn test_from_dberr_try_into_err_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let source_err: Arc<dyn std::error::Error + Send + Sync> = Arc::new(std::io::Error::new(
std::io::ErrorKind::InvalidData,
"bad value",
));
let db_err = DbErr::TryIntoErr {
from: "String",
into: "i32",
source: source_err,
};
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("String"));
assert!(tx_err.to_string().contains("i32"));
}
#[test]
fn test_from_dberr_conn_runtime_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::Conn(dbnexus::sea_orm::RuntimeErr::Internal(
"conn lost".to_string(),
));
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("conn lost"));
}
#[test]
fn test_from_dberr_exec_runtime_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::Exec(dbnexus::sea_orm::RuntimeErr::Internal(
"exec fail".to_string(),
));
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("exec fail"));
}
#[test]
fn test_from_dberr_record_not_updated_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::RecordNotUpdated;
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
}
#[test]
fn test_from_dberr_unpack_insert_id_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::UnpackInsertId;
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
}
#[test]
fn test_from_dberr_type_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::Type("invalid type".to_string());
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("invalid type"));
}
#[test]
fn test_from_dberr_json_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::Json("parse error".to_string());
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("parse error"));
}
#[test]
fn test_from_dberr_convert_from_u64_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::ConvertFromU64("String");
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
}
#[test]
fn test_from_dberr_attr_type_to_transaction_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let db_err = DbErr::AttrNotSet("version".to_string());
let tx_err: TransactionError = db_err.into();
assert!(matches!(tx_err, TransactionError::DatabaseError(_)));
assert!(tx_err.to_string().contains("version"));
}
#[test]
fn test_transaction_error_begin_failed_display_contains_prefix() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::BeginFailed("conn refused".to_string());
let msg = err.to_string();
assert!(msg.contains("Failed to begin transaction"));
assert!(msg.contains("conn refused"));
}
#[test]
fn test_transaction_error_commit_failed_display_contains_prefix() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::CommitFailed("timeout".to_string());
let msg = err.to_string();
assert!(msg.contains("Failed to commit transaction"));
assert!(msg.contains("timeout"));
}
#[test]
fn test_transaction_error_rollback_failed_display_contains_prefix() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::RollbackFailed("deadlock".to_string());
let msg = err.to_string();
assert!(msg.contains("Failed to rollback transaction"));
assert!(msg.contains("deadlock"));
}
#[test]
fn test_transaction_error_savepoint_failed_display_contains_both_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::SavepointFailed {
name: "before_op".to_string(),
message: "duplicate".to_string(),
};
let msg = err.to_string();
assert!(msg.contains("Failed to create savepoint"));
assert!(msg.contains("before_op"));
assert!(msg.contains("duplicate"));
}
#[test]
fn test_transaction_error_release_savepoint_failed_display_contains_both_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::ReleaseSavepointFailed {
name: "sp1".to_string(),
message: "not found".to_string(),
};
let msg = err.to_string();
assert!(msg.contains("Failed to release savepoint"));
assert!(msg.contains("sp1"));
assert!(msg.contains("not found"));
}
#[test]
fn test_transaction_error_rollback_to_savepoint_failed_display_contains_both_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::RollbackToSavepointFailed {
name: "sp2".to_string(),
message: "connection lost".to_string(),
};
let msg = err.to_string();
assert!(msg.contains("Failed to rollback to savepoint"));
assert!(msg.contains("sp2"));
assert!(msg.contains("connection lost"));
}
#[test]
fn test_transaction_error_database_error_display_contains_message() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::DatabaseError("query panicked".to_string());
let msg = err.to_string();
assert!(msg.contains("Database error"));
assert!(msg.contains("query panicked"));
}
#[test]
fn test_transaction_error_invalid_savepoint_name_display_contains_message() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::InvalidSavepointName("too long".to_string());
let msg = err.to_string();
assert!(msg.contains("Invalid savepoint name"));
assert!(msg.contains("too long"));
}
#[test]
fn test_transaction_error_savepoint_not_found_display_contains_name() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::SavepointNotFound("sp_xyz".to_string());
let msg = err.to_string();
assert!(msg.contains("Savepoint not found"));
assert!(msg.contains("sp_xyz"));
}
#[test]
fn test_transaction_error_no_active_transaction_display_exact() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::NoActiveTransaction;
assert_eq!(err.to_string(), "No active transaction");
}
#[test]
fn test_transaction_error_transaction_already_active_display_exact() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let err = TransactionError::TransactionAlreadyActive;
assert_eq!(err.to_string(), "Transaction already active");
}
#[test]
fn test_transaction_error_implements_debug_for_all_variants() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let variants: Vec<TransactionError> = vec![
TransactionError::BeginFailed("e".into()),
TransactionError::CommitFailed("e".into()),
TransactionError::RollbackFailed("e".into()),
TransactionError::SavepointFailed {
name: "n".into(),
message: "m".into(),
},
TransactionError::ReleaseSavepointFailed {
name: "n".into(),
message: "m".into(),
},
TransactionError::RollbackToSavepointFailed {
name: "n".into(),
message: "m".into(),
},
TransactionError::NoActiveTransaction,
TransactionError::TransactionAlreadyActive,
TransactionError::InvalidSavepointName("n".into()),
TransactionError::SavepointNotFound("n".into()),
TransactionError::DatabaseError("e".into()),
];
for err in &variants {
let debug = format!("{:?}", err);
assert!(!debug.is_empty());
}
}
#[test]
fn test_transaction_isolation_default_is_read_committed() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let iso: TransactionIsolation = Default::default();
assert!(matches!(iso, TransactionIsolation::ReadCommitted));
}
#[test]
fn test_transaction_access_default_is_read_write() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let acc: TransactionAccess = Default::default();
assert!(matches!(acc, TransactionAccess::ReadWrite));
}
#[test]
fn test_transaction_isolation_clone_preserves_variant() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
for iso in [
TransactionIsolation::ReadUncommitted,
TransactionIsolation::ReadCommitted,
TransactionIsolation::RepeatableRead,
TransactionIsolation::Serializable,
] {
let cloned = iso;
assert!(
matches!(cloned, TransactionIsolation::ReadUncommitted)
|| matches!(cloned, TransactionIsolation::ReadCommitted)
|| matches!(cloned, TransactionIsolation::RepeatableRead)
|| matches!(cloned, TransactionIsolation::Serializable)
);
let _ = iso;
}
}
#[test]
fn test_transaction_access_clone_preserves_variant() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
for acc in [TransactionAccess::ReadWrite, TransactionAccess::ReadOnly] {
let cloned = acc;
assert!(
matches!(cloned, TransactionAccess::ReadWrite)
|| matches!(cloned, TransactionAccess::ReadOnly)
);
let _ = acc;
}
}
#[test]
fn test_transaction_config_clone_preserves_all_fields() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let config = TransactionConfig {
isolation_level: TransactionIsolation::RepeatableRead,
access_mode: TransactionAccess::ReadOnly,
enable_savepoints: false,
role: "viewer".to_string(),
};
let cloned = config.clone();
assert!(matches!(
cloned.isolation_level,
TransactionIsolation::RepeatableRead
));
assert!(matches!(cloned.access_mode, TransactionAccess::ReadOnly));
assert!(!cloned.enable_savepoints);
assert_eq!(cloned.role, "viewer");
}
#[test]
fn test_transaction_config_debug_format_works() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let config = TransactionConfig::default();
let debug = format!("{:?}", config);
assert!(debug.contains("TransactionConfig"));
assert!(debug.contains("admin"));
assert!(debug.contains("true"));
}
#[tokio::test]
async fn test_savepoint_name_single_char_passes_validation_no_tx() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("a").await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_savepoint_name_single_underscore_passes_validation_no_tx() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("_").await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_savepoint_name_digits_only_passes_validation_no_tx() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("12345").await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_savepoint_name_unicode_alphanumeric_rejected_no_tx() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("测试点").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_savepoint_name_tab_character_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("sp\t1").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_savepoint_name_newline_character_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("sp\n1").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_savepoint_name_emoji_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.savepoint("sp🎉").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_savepoint_name_at_max_boundary_passes_validation_no_tx() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let name = "a".repeat(63);
let result = manager.savepoint(&name).await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[tokio::test]
async fn test_savepoint_name_one_over_max_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let name = "a".repeat(64);
let result = manager.savepoint(&name).await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
assert!(result.unwrap_err().to_string().contains("too long"));
}
#[tokio::test]
async fn test_release_savepoint_too_long_name_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let name = "a".repeat(64);
let result = manager.release_savepoint(&name).await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_rollback_to_savepoint_too_long_name_rejected() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let name = "a".repeat(64);
let result = manager.rollback_to_savepoint(&name).await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_release_savepoint_unicode_name_rejected_validation_only_for_chars() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.release_savepoint("释放点").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_rollback_to_savepoint_unicode_name_rejected_no_tx() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let result = manager.rollback_to_savepoint("回滚点").await;
assert!(matches!(
result,
Err(TransactionError::InvalidSavepointName(_))
));
}
#[tokio::test]
async fn test_begin_with_config_savepoints_disabled_succeeds_with_real_db() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let config = TransactionConfig {
isolation_level: TransactionIsolation::ReadUncommitted,
access_mode: TransactionAccess::ReadWrite,
enable_savepoints: false,
role: "admin".to_string(),
};
let manager = TransactionManager::with_config(pool, config.clone());
let result = manager.begin_with_config(config).await;
assert!(
result.is_ok(),
"expected Ok with real DB connection, got {:?}",
result.err()
);
assert!(manager.is_active());
assert!(manager.has_transaction());
let _ = manager.rollback().await;
}
#[tokio::test]
async fn test_begin_with_config_admin_role_succeeds() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let config = TransactionConfig {
isolation_level: TransactionIsolation::Serializable,
access_mode: TransactionAccess::ReadOnly,
enable_savepoints: true,
role: "admin".to_string(),
};
let manager = TransactionManager::with_config(pool, config.clone());
let result = manager.begin_with_config(config).await;
assert!(
result.is_ok(),
"expected Ok with admin role, got {:?}",
result.err()
);
assert!(manager.is_active());
let _ = manager.rollback().await;
}
#[tokio::test]
async fn test_begin_with_config_empty_role_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let config = TransactionConfig {
isolation_level: TransactionIsolation::ReadCommitted,
access_mode: TransactionAccess::ReadWrite,
enable_savepoints: true,
role: "".to_string(),
};
let manager = TransactionManager::with_config(pool, config.clone());
let result = manager.begin_with_config(config).await;
assert!(result.is_err());
assert!(!manager.is_active());
}
#[test]
fn test_guard_drop_in_inner_scope_does_not_panic() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
{
let _guard_outer = TransactionGuard::new(&manager);
{
let _guard_inner = TransactionGuard::new(&manager);
}
assert!(!manager.is_active());
}
assert!(!manager.is_active());
}
#[test]
fn test_guard_can_be_created_and_dropped_multiple_times() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
for _ in 0..5 {
let _guard = TransactionGuard::new(&manager);
}
assert!(!manager.is_active());
}
#[tokio::test]
async fn test_guard_commit_called_twide_after_drop_returns_error() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
let guard = TransactionGuard::new(&manager);
let result = guard.commit().await;
assert!(matches!(result, Err(TransactionError::NoActiveTransaction)));
}
#[test]
fn test_drop_with_configured_manager_no_active_transaction_no_panic() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let config = TransactionConfig {
isolation_level: TransactionIsolation::Serializable,
access_mode: TransactionAccess::ReadOnly,
enable_savepoints: false,
role: "viewer".to_string(),
};
let manager = TransactionManager::with_config(pool, config);
drop(manager);
}
#[test]
fn test_drop_after_failed_begin_does_not_panic() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
drop(manager);
}
#[test]
fn test_validate_savepoint_name_valid_names_direct() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
for name in &["sp1", "savepoint_1", "SAVEPOINT_1", "sp123", "_sp", "a"] {
assert!(
validate_savepoint_name(name).is_ok(),
"'{}' should be valid",
name
);
}
}
#[test]
fn test_validate_savepoint_name_special_chars_direct() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
for name in &["sp@1", "sp.1", "sp/1", "sp-1", "sp!1", "sp#1", "sp 1"] {
assert!(
validate_savepoint_name(name).is_err(),
"'{}' should be rejected",
name
);
}
}
#[test]
fn test_validate_savepoint_name_unicode_direct() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
assert!(validate_savepoint_name("释放点").is_err());
}
#[test]
fn test_savepoint_count_zero_without_active_transaction() {
if crate::common::test_helpers::skip_if_no_test_db() {
return;
}
let pool = create_test_db_pool();
let manager = TransactionManager::new(pool);
assert_eq!(manager.savepoint_count(), 0);
}
}