Struct TestTransaction 

pub struct TestTransaction<C> { /* private fields */ }

A test transaction that automatically rolls back on drop.

This provides a way to run database tests in isolation without affecting other tests or leaving test data in the database.

Behavior

When TestTransaction is dropped, it will automatically rollback all changes made during the test. This ensures that:

• Tests don’t affect each other
• No test data is left in the database
• Tests can be run in parallel without conflicts

Example

let tx = TestTransaction::begin(&pool).await?;

// All operations here happen within the transaction
sqlx::query("INSERT INTO users (name) VALUES ('test')")
    .execute(tx.connection())
    .await?;

// When tx goes out of scope, all changes are rolled back

Implementations

impl<C> TestTransaction<C>

pub fn new(connection: C) -> Self

Create a new test transaction wrapper.

pub fn commit_on_drop(self) -> Self

Configure the transaction to commit on drop instead of rollback.

Use this with caution - it defeats the purpose of test isolation.

pub fn connection(&self) -> &C

Get a reference to the underlying connection.

pub fn connection_mut(&mut self) -> &mut C

Get a mutable reference to the underlying connection.

pub fn into_inner(self) -> C

Consume the transaction and return the underlying connection.

Note: This prevents automatic rollback/commit on drop.

pub fn mark_completed(&mut self)

Mark the transaction as completed (no rollback on drop).

Trait Implementations

impl<C: Debug> Debug for TestTransaction<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C> Deref for TestTransaction<C>

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.