mssql-testing

Part of the rust-mssql-driver project.

Test infrastructure for SQL Server driver development.

Overview

This crate provides utilities for integration testing against SQL Server instances, including testcontainers support for spinning up real SQL Server instances and a mock TDS server for unit tests that don't require Docker.

Features

• SQL Server containers - Managed test containers via testcontainers
• Mock TDS server - Simulate SQL Server responses without Docker
• Packet recording - Capture and replay TDS traffic for regression tests
• Test fixtures - Common test data and helpers
• Connection helpers - Simplified test connection setup

Mock Server

The mock server simulates TDS protocol responses for unit testing:

use mssql_testing::mock_server::{MockTdsServer, MockResponse, MockColumn, ScalarValue};

#[tokio::test]
async fn test_with_mock_server() {
    let server = MockTdsServer::builder()
        .with_response(
            "SELECT * FROM users WHERE id = 1",
            MockResponse::rows(
                vec![MockColumn::int("id"), MockColumn::nvarchar("name", 50)],
                vec![vec![ScalarValue::Int(1), ScalarValue::String("Alice".into())]],
            ),
        )
        .with_response(
            "SELECT COUNT(*) FROM users",
            MockResponse::scalar(ScalarValue::Int(42)),
        )
        .build()
        .await
        .unwrap();

    let addr = server.addr();
    // Connect your client to addr...
}

SQL Server Containers

Spin up real SQL Server instances for integration tests:

use mssql_testing::SqlServerContainer;
use testcontainers::clients::Cli;

#[tokio::test]
async fn test_with_real_server() {
    let docker = Cli::default();
    let container = docker.run(SqlServerContainer::default());
    let port = container.get_host_port_ipv4(1433);

    // Connect to localhost:port with sa/YourStrong!Passw0rd
}

Container Versions

// SQL Server 2019
let container = SqlServerContainer::sql_server_2019();

// SQL Server 2022
let container = SqlServerContainer::sql_server_2022();

// Custom image
let container = SqlServerContainer::new("mcr.microsoft.com/mssql/server:2022-latest");

Packet Recording

Record and replay TDS packets for regression testing:

use mssql_testing::mock_server::{PacketRecorder, RecordedPacket};

// Record packets during a test run
let recorder = PacketRecorder::new();
// ... run operations ...
let packets: Vec<RecordedPacket> = recorder.packets();

// Save for later replay
let json = serde_json::to_string(&packets)?;

// Replay recorded packets
let server = MockTdsServer::builder()
    .with_recorded_packets(packets)
    .build()
    .await?;

Test Fixtures

Common test data and helpers:

use mssql_testing::fixtures::{test_connection_string, test_database_setup};

// Get a test connection string (from env or default)
let conn_str = test_connection_string();

// Set up a test database with schema
test_database_setup(&mut client, r#"
    CREATE TABLE users (
        id INT PRIMARY KEY,
        name NVARCHAR(100)
    );
    INSERT INTO users VALUES (1, 'Alice'), (2, 'Bob');
"#).await?;

Modules

Key Types

Mock Response Types

// Empty result (no rows)
MockResponse::empty()

// Single scalar value
MockResponse::scalar(ScalarValue::Int(42))

// Rows with columns
MockResponse::rows(
    vec![MockColumn::int("count")],
    vec![vec![ScalarValue::Int(100)]],
)

// Error response
MockResponse::error(8134, "Divide by zero error")

// Affected row count (for INSERT/UPDATE/DELETE)
MockResponse::affected_rows(5)

Best Practices

1. Use mock server for unit tests - Fast, no Docker dependency
2. Use containers for integration tests - Real SQL Server behavior
3. Record packets for regression tests - Catch protocol changes
4. Clean up test databases - Use fixtures for consistent state

License

MIT OR Apache-2.0