Testing Strategies Guide

import pytest
from myapp.queries import QueryBuilder, PersonFilters

class TestQueryBuilder:
    def test_build_person_query_by_name(self):
        filters = PersonFilters(name="Alice")
        query = QueryBuilder.build_person_query(filters)
        assert query == "MATCH (p:Person {name: $name}) RETURN p"

    def test_build_person_query_by_age_range(self):
        filters = PersonFilters(min_age=18, max_age=65)
        query = QueryBuilder.build_person_query(filters)
        expected = "MATCH (p:Person) WHERE p.age >= $min_age AND p.age <= $max_age RETURN p"
        assert query == expected

    def test_build_person_query_with_relationships(self):
        filters = PersonFilters(has_friends=True)
        query = QueryBuilder.build_person_query(filters)
        assert query == "MATCH (p:Person)-[:KNOWS]->() RETURN DISTINCT p"

    @pytest.mark.parametrize("depth,expected", [
        (1, "MATCH (a)-[:KNOWS*1..1]->(b) RETURN a, b"),
        (2, "MATCH (a)-[:KNOWS*1..2]->(b) RETURN a, b"),
        (5, "MATCH (a)-[:KNOWS*1..5]->(b) RETURN a, b"),
    ])
    def test_build_relationship_query_depth(self, depth, expected):
        query = QueryBuilder.build_relationship_query("KNOWS", depth)
        assert query == expected


class TestQueryParameters:
    def test_add_and_get_parameters(self):
        params = QueryBuilder.new_params()
        params.add("name", "Alice")
        params.add("age", 30)

        assert params.get("name") == "Alice"
        assert params.get("age") == 30
        assert params.get("unknown") is None

    def test_parameter_type_validation(self):
        params = QueryBuilder.new_params()

        # Valid types
        params.add("string_val", "test")
        params.add("int_val", 42)
        params.add("float_val", 3.14)
        params.add("bool_val", True)
        params.add("list_val", [1, 2, 3])

        # Invalid type should raise
        with pytest.raises(TypeError):
            params.add("invalid", object())

#[cfg(test)]
mod tests {
    use super::*;
    use crate::queries::{QueryBuilder, PersonFilters};

    #[test]
    fn test_build_person_query_by_name() {
        let filters = PersonFilters {
            name: Some("Alice".to_string()),
            ..Default::default()
        };
        let query = QueryBuilder::build_person_query(&filters);
        assert_eq!(query, "MATCH (p:Person {name: $name}) RETURN p");
    }

    #[test]
    fn test_build_person_query_by_age_range() {
        let filters = PersonFilters {
            min_age: Some(18),
            max_age: Some(65),
            ..Default::default()
        };
        let query = QueryBuilder::build_person_query(&filters);
        let expected = "MATCH (p:Person) WHERE p.age >= $min_age AND p.age <= $max_age RETURN p";
        assert_eq!(query, expected);
    }

    #[test]
    fn test_build_person_query_with_relationships() {
        let filters = PersonFilters {
            has_friends: true,
            ..Default::default()
        };
        let query = QueryBuilder::build_person_query(&filters);
        assert_eq!(query, "MATCH (p:Person)-[:KNOWS]->() RETURN DISTINCT p");
    }

    #[test]
    fn test_build_relationship_query_depths() {
        let test_cases = vec![
            (1, "MATCH (a)-[:KNOWS*1..1]->(b) RETURN a, b"),
            (2, "MATCH (a)-[:KNOWS*1..2]->(b) RETURN a, b"),
            (5, "MATCH (a)-[:KNOWS*1..5]->(b) RETURN a, b"),
        ];

        for (depth, expected) in test_cases {
            let query = QueryBuilder::build_relationship_query("KNOWS", depth);
            assert_eq!(query, expected);
        }
    }

    #[test]
    fn test_query_parameters() {
        let mut params = QueryBuilder::new_params();
        params.add("name", Value::String("Alice".to_string()));
        params.add("age", Value::Int(30));

        assert_eq!(params.get("name"), Some(&Value::String("Alice".to_string())));
        assert_eq!(params.get("age"), Some(&Value::Int(30)));
        assert_eq!(params.get("unknown"), None);
    }
}

import { describe, it, expect } from 'vitest';
import { QueryBuilder, PersonFilters } from './queries';

describe('QueryBuilder', () => {
    describe('buildPersonQuery', () => {
        it('should build query by name', () => {
            const filters: PersonFilters = { name: 'Alice' };
            const query = QueryBuilder.buildPersonQuery(filters);
            expect(query).toBe('MATCH (p:Person {name: $name}) RETURN p');
        });

        it('should build query by age range', () => {
            const filters: PersonFilters = { minAge: 18, maxAge: 65 };
            const query = QueryBuilder.buildPersonQuery(filters);
            expect(query).toBe(
                'MATCH (p:Person) WHERE p.age >= $min_age AND p.age <= $max_age RETURN p'
            );
        });

        it('should build query with relationships', () => {
            const filters: PersonFilters = { hasFriends: true };
            const query = QueryBuilder.buildPersonQuery(filters);
            expect(query).toBe('MATCH (p:Person)-[:KNOWS]->() RETURN DISTINCT p');
        });
    });

    describe('buildRelationshipQuery', () => {
        it.each([
            [1, 'MATCH (a)-[:KNOWS*1..1]->(b) RETURN a, b'],
            [2, 'MATCH (a)-[:KNOWS*1..2]->(b) RETURN a, b'],
            [5, 'MATCH (a)-[:KNOWS*1..5]->(b) RETURN a, b'],
        ])('should build query with depth %i', (depth, expected) => {
            const query = QueryBuilder.buildRelationshipQuery('KNOWS', depth);
            expect(query).toBe(expected);
        });
    });

    describe('QueryParameters', () => {
        it('should add and get parameters', () => {
            const params = QueryBuilder.newParams();
            params.add('name', 'Alice');
            params.add('age', 30);

            expect(params.get('name')).toBe('Alice');
            expect(params.get('age')).toBe(30);
            expect(params.get('unknown')).toBeUndefined();
        });

        it('should validate parameter types', () => {
            const params = QueryBuilder.newParams();

            // Valid types
            expect(() => params.add('string', 'test')).not.toThrow();
            expect(() => params.add('number', 42)).not.toThrow();
            expect(() => params.add('boolean', true)).not.toThrow();
            expect(() => params.add('array', [1, 2, 3])).not.toThrow();

            // Invalid type
            expect(() => params.add('invalid', Symbol())).toThrow(TypeError);
        });
    });
});

const std = @import("std");
const testing = std.testing;
const queries = @import("queries.zig");
const QueryBuilder = queries.QueryBuilder;
const PersonFilters = queries.PersonFilters;

test "build person query by name" {
    const filters = PersonFilters{ .name = "Alice" };
    const query = QueryBuilder.buildPersonQuery(filters);
    try testing.expectEqualStrings(
        "MATCH (p:Person {name: $name}) RETURN p",
        query,
    );
}

test "build person query by age range" {
    const filters = PersonFilters{ .min_age = 18, .max_age = 65 };
    const query = QueryBuilder.buildPersonQuery(filters);
    try testing.expectEqualStrings(
        "MATCH (p:Person) WHERE p.age >= $min_age AND p.age <= $max_age RETURN p",
        query,
    );
}

test "build person query with relationships" {
    const filters = PersonFilters{ .has_friends = true };
    const query = QueryBuilder.buildPersonQuery(filters);
    try testing.expectEqualStrings(
        "MATCH (p:Person)-[:KNOWS]->() RETURN DISTINCT p",
        query,
    );
}

test "build relationship query with various depths" {
    const test_cases = .{
        .{ 1, "MATCH (a)-[:KNOWS*1..1]->(b) RETURN a, b" },
        .{ 2, "MATCH (a)-[:KNOWS*1..2]->(b) RETURN a, b" },
        .{ 5, "MATCH (a)-[:KNOWS*1..5]->(b) RETURN a, b" },
    };

    inline for (test_cases) |case| {
        const depth = case[0];
        const expected = case[1];
        const query = QueryBuilder.buildRelationshipQuery("KNOWS", depth);
        try testing.expectEqualStrings(expected, query);
    }
}

test "query parameters add and get" {
    var allocator = testing.allocator;
    var params = QueryBuilder.newParams(allocator);
    defer params.deinit();

    try params.add("name", .{ .string = "Alice" });
    try params.add("age", .{ .integer = 30 });

    try testing.expectEqualStrings("Alice", params.get("name").?.string);
    try testing.expectEqual(@as(i64, 30), params.get("age").?.integer);
    try testing.expect(params.get("unknown") == null);
}

import pytest
from myapp.transform import PersonTransformer, RelationshipTransformer
from myapp.models import Person, Relationship

class TestPersonTransformer:
    def test_transform_person_result(self):
        raw_result = {
            "p.name": "Alice",
            "p.age": 30,
            "p.city": "New York"
        }

        person = PersonTransformer.from_result(raw_result)
        assert person.name == "Alice"
        assert person.age == 30
        assert person.city == "New York"

    def test_transform_person_result_missing_field(self):
        raw_result = {
            "p.name": "Alice",
            # Missing age and city
        }

        with pytest.raises(ValueError, match="missing required field"):
            PersonTransformer.from_result(raw_result)

    def test_transform_person_result_null_values(self):
        raw_result = {
            "p.name": "Alice",
            "p.age": 30,
            "p.city": None  # Optional field can be null
        }

        person = PersonTransformer.from_result(raw_result)
        assert person.name == "Alice"
        assert person.city is None


class TestRelationshipTransformer:
    def test_transform_relationship_result(self):
        raw_result = {
            "r.type": "KNOWS",
            "r.since": 2020,
            "from": "Alice",
            "to": "Bob"
        }

        rel = RelationshipTransformer.from_result(raw_result)
        assert rel.type == "KNOWS"
        assert rel.since == 2020
        assert rel.from_node == "Alice"
        assert rel.to_node == "Bob"

#[cfg(test)]
mod transform_tests {
    use super::*;
    use crate::transform::{PersonTransformer, RelationshipTransformer};
    use std::collections::HashMap;

    #[test]
    fn test_transform_person_result() {
        let mut raw_result = HashMap::new();
        raw_result.insert("p.name".to_string(), Value::String("Alice".to_string()));
        raw_result.insert("p.age".to_string(), Value::Int(30));
        raw_result.insert("p.city".to_string(), Value::String("New York".to_string()));

        let person = PersonTransformer::from_result(&raw_result).unwrap();
        assert_eq!(person.name, "Alice");
        assert_eq!(person.age, 30);
        assert_eq!(person.city, Some("New York".to_string()));
    }

    #[test]
    fn test_transform_person_result_missing_field() {
        let mut raw_result = HashMap::new();
        raw_result.insert("p.name".to_string(), Value::String("Alice".to_string()));
        // Missing age and city

        let result = PersonTransformer::from_result(&raw_result);
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("missing required field"));
    }

    #[test]
    fn test_transform_relationship_result() {
        let mut raw_result = HashMap::new();
        raw_result.insert("r.type".to_string(), Value::String("KNOWS".to_string()));
        raw_result.insert("r.since".to_string(), Value::Int(2020));
        raw_result.insert("from".to_string(), Value::String("Alice".to_string()));
        raw_result.insert("to".to_string(), Value::String("Bob".to_string()));

        let rel = RelationshipTransformer::from_result(&raw_result).unwrap();
        assert_eq!(rel.rel_type, "KNOWS");
        assert_eq!(rel.since, Some(2020));
        assert_eq!(rel.from, "Alice");
        assert_eq!(rel.to, "Bob");
    }
}

import { describe, it, expect } from 'vitest';
import { PersonTransformer, RelationshipTransformer } from './transform';

describe('PersonTransformer', () => {
    it('should transform person result', () => {
        const rawResult = {
            'p.name': 'Alice',
            'p.age': 30,
            'p.city': 'New York',
        };

        const person = PersonTransformer.fromResult(rawResult);
        expect(person.name).toBe('Alice');
        expect(person.age).toBe(30);
        expect(person.city).toBe('New York');
    });

    it('should throw on missing required field', () => {
        const rawResult = {
            'p.name': 'Alice',
            // Missing age and city
        };

        expect(() => PersonTransformer.fromResult(rawResult)).toThrow(
            'missing required field'
        );
    });

    it('should handle null optional values', () => {
        const rawResult = {
            'p.name': 'Alice',
            'p.age': 30,
            'p.city': null,
        };

        const person = PersonTransformer.fromResult(rawResult);
        expect(person.city).toBeNull();
    });
});

describe('RelationshipTransformer', () => {
    it('should transform relationship result', () => {
        const rawResult = {
            'r.type': 'KNOWS',
            'r.since': 2020,
            from: 'Alice',
            to: 'Bob',
        };

        const rel = RelationshipTransformer.fromResult(rawResult);
        expect(rel.type).toBe('KNOWS');
        expect(rel.since).toBe(2020);
        expect(rel.from).toBe('Alice');
        expect(rel.to).toBe('Bob');
    });
});

const std = @import("std");
const testing = std.testing;
const transform = @import("transform.zig");

test "transform person result" {
    var allocator = testing.allocator;

    var raw_result = std.StringHashMap(transform.Value).init(allocator);
    defer raw_result.deinit();

    try raw_result.put("p.name", .{ .string = "Alice" });
    try raw_result.put("p.age", .{ .integer = 30 });
    try raw_result.put("p.city", .{ .string = "New York" });

    const person = try transform.PersonTransformer.fromResult(allocator, &raw_result);
    defer allocator.free(person.name);

    try testing.expectEqualStrings("Alice", person.name);
    try testing.expectEqual(@as(i64, 30), person.age);
    try testing.expectEqualStrings("New York", person.city.?);
}

test "transform person result missing field" {
    var allocator = testing.allocator;

    var raw_result = std.StringHashMap(transform.Value).init(allocator);
    defer raw_result.deinit();

    try raw_result.put("p.name", .{ .string = "Alice" });
    // Missing age and city

    const result = transform.PersonTransformer.fromResult(allocator, &raw_result);
    try testing.expectError(error.MissingRequiredField, result);
}

test "transform relationship result" {
    var allocator = testing.allocator;

    var raw_result = std.StringHashMap(transform.Value).init(allocator);
    defer raw_result.deinit();

    try raw_result.put("r.type", .{ .string = "KNOWS" });
    try raw_result.put("r.since", .{ .integer = 2020 });
    try raw_result.put("from", .{ .string = "Alice" });
    try raw_result.put("to", .{ .string = "Bob" });

    const rel = try transform.RelationshipTransformer.fromResult(allocator, &raw_result);

    try testing.expectEqualStrings("KNOWS", rel.rel_type);
    try testing.expectEqual(@as(i64, 2020), rel.since.?);
    try testing.expectEqualStrings("Alice", rel.from);
    try testing.expectEqualStrings("Bob", rel.to);
}

import pytest
import asyncio
from testcontainers.core.container import DockerContainer
from testcontainers.core.waiting_utils import wait_for_logs
from geode_client import Client

class GeodeContainer(DockerContainer):
    def __init__(self):
        super().__init__("geodedb/geode:latest")
        self.with_exposed_ports(3141)
        self.with_command("serve --listen 0.0.0.0:3141")

    def get_connection_url(self) -> tuple[str, int]:
        host = self.get_container_host_ip()
        port = int(self.get_exposed_port(3141))
        return host, port

@pytest.fixture(scope="session")
def geode_container():
    """Start Geode container for the test session."""
    container = GeodeContainer()
    container.start()
    wait_for_logs(container, "Server listening", timeout=60)
    yield container
    container.stop()

@pytest.fixture
async def geode_client(geode_container):
    """Create a Geode client connected to the test container."""
    host, port = geode_container.get_connection_url()
    client = Client(host=host, port=port, skip_verify=True)
    yield client
    # Cleanup is handled by context manager

@pytest.fixture
async def clean_db(geode_client):
    """Clean database before each test."""
    async with geode_client.connection() as conn:
        await conn.execute("MATCH (n) DETACH DELETE n")
    yield

@pytest.mark.asyncio
class TestGeodeIntegration:
    async def test_create_and_query_person(self, geode_client, clean_db):
        async with geode_client.connection() as conn:
            # Create person
            await conn.execute(
                "CREATE (:Person {name: $name, age: $age})",
                {"name": "Alice", "age": 30}
            )

            # Query person
            page, _ = await conn.query(
                "MATCH (p:Person {name: $name}) RETURN p.name, p.age",
                {"name": "Alice"}
            )

            assert len(page.rows) == 1
            row = page.rows[0]
            assert row["p.name"].as_string == "Alice"
            assert row["p.age"].as_int == 30

    async def test_create_relationship(self, geode_client, clean_db):
        async with geode_client.connection() as conn:
            # Create nodes
            await conn.execute(
                "CREATE (:Person {name: $name})",
                {"name": "Alice"}
            )
            await conn.execute(
                "CREATE (:Person {name: $name})",
                {"name": "Bob"}
            )

            # Create relationship
            await conn.execute("""
                MATCH (a:Person {name: $from}), (b:Person {name: $to})
                CREATE (a)-[:KNOWS {since: $since}]->(b)
            """, {"from": "Alice", "to": "Bob", "since": 2020})

            # Verify relationship
            page, _ = await conn.query("""
                MATCH (a:Person)-[r:KNOWS]->(b:Person)
                RETURN a.name, b.name, r.since
            """)

            assert len(page.rows) == 1
            row = page.rows[0]
            assert row["a.name"].as_string == "Alice"
            assert row["b.name"].as_string == "Bob"
            assert row["r.since"].as_int == 2020

    async def test_transaction_rollback(self, geode_client, clean_db):
        async with geode_client.connection() as conn:
            # Start transaction
            await conn.begin()

            # Create person
            await conn.execute(
                "CREATE (:Person {name: $name})",
                {"name": "Alice"}
            )

            # Rollback
            await conn.rollback()

            # Verify person was not created
            page, _ = await conn.query(
                "MATCH (p:Person {name: $name}) RETURN p",
                {"name": "Alice"}
            )
            assert len(page.rows) == 0

use geode_client::{Client, Value};
use std::collections::HashMap;
use testcontainers::{clients::Cli, core::WaitFor, GenericImage};

struct GeodeContainer {
    _container: testcontainers::Container<'static, GenericImage>,
    host: String,
    port: u16,
}

impl GeodeContainer {
    async fn new(docker: &'static Cli) -> Self {
        let image = GenericImage::new("geodedb/geode", "latest")
            .with_exposed_port(3141)
            .with_wait_for(WaitFor::message_on_stdout("Server listening"));

        let container = docker.run(image);
        let host = "127.0.0.1".to_string();
        let port = container.get_host_port_ipv4(3141);

        Self {
            _container: container,
            host,
            port,
        }
    }

    fn connection_info(&self) -> (&str, u16) {
        (&self.host, self.port)
    }
}

#[tokio::test]
async fn test_create_and_query_person() {
    let docker = Cli::default();
    let geode = GeodeContainer::new(&docker).await;
    let (host, port) = geode.connection_info();

    let client = Client::new(host, port).skip_verify(true);
    let mut conn = client.connect().await.unwrap();

    // Clean database
    conn.query("MATCH (n) DETACH DELETE n").await.unwrap();

    // Create person
    let mut params = HashMap::new();
    params.insert("name".to_string(), Value::string("Alice"));
    params.insert("age".to_string(), Value::int(30));
    conn.query_with_params(
        "CREATE (:Person {name: $name, age: $age})",
        &params
    ).await.unwrap();

    // Query person
    let mut query_params = HashMap::new();
    query_params.insert("name".to_string(), Value::string("Alice"));
    let (page, _) = conn.query_with_params(
        "MATCH (p:Person {name: $name}) RETURN p.name, p.age",
        &query_params
    ).await.unwrap();

    assert_eq!(page.rows.len(), 1);
    let row = &page.rows[0];
    assert_eq!(row.get("p.name").unwrap().as_string().unwrap(), "Alice");
    assert_eq!(row.get("p.age").unwrap().as_int().unwrap(), 30);
}

#[tokio::test]
async fn test_create_relationship() {
    let docker = Cli::default();
    let geode = GeodeContainer::new(&docker).await;
    let (host, port) = geode.connection_info();

    let client = Client::new(host, port).skip_verify(true);
    let mut conn = client.connect().await.unwrap();

    // Clean database
    conn.query("MATCH (n) DETACH DELETE n").await.unwrap();

    // Create nodes
    let mut params = HashMap::new();
    params.insert("name".to_string(), Value::string("Alice"));
    conn.query_with_params("CREATE (:Person {name: $name})", &params).await.unwrap();

    params.insert("name".to_string(), Value::string("Bob"));
    conn.query_with_params("CREATE (:Person {name: $name})", &params).await.unwrap();

    // Create relationship
    let mut rel_params = HashMap::new();
    rel_params.insert("from".to_string(), Value::string("Alice"));
    rel_params.insert("to".to_string(), Value::string("Bob"));
    rel_params.insert("since".to_string(), Value::int(2020));
    conn.query_with_params(r#"
        MATCH (a:Person {name: $from}), (b:Person {name: $to})
        CREATE (a)-[:KNOWS {since: $since}]->(b)
    "#, &rel_params).await.unwrap();

    // Verify relationship
    let (page, _) = conn.query(r#"
        MATCH (a:Person)-[r:KNOWS]->(b:Person)
        RETURN a.name, b.name, r.since
    "#).await.unwrap();

    assert_eq!(page.rows.len(), 1);
    let row = &page.rows[0];
    assert_eq!(row.get("a.name").unwrap().as_string().unwrap(), "Alice");
    assert_eq!(row.get("b.name").unwrap().as_string().unwrap(), "Bob");
    assert_eq!(row.get("r.since").unwrap().as_int().unwrap(), 2020);
}

#[tokio::test]
async fn test_transaction_rollback() {
    let docker = Cli::default();
    let geode = GeodeContainer::new(&docker).await;
    let (host, port) = geode.connection_info();

    let client = Client::new(host, port).skip_verify(true);
    let mut conn = client.connect().await.unwrap();

    // Clean database
    conn.query("MATCH (n) DETACH DELETE n").await.unwrap();

    // Start transaction
    conn.begin().await.unwrap();

    // Create person
    let mut params = HashMap::new();
    params.insert("name".to_string(), Value::string("Alice"));
    conn.query_with_params("CREATE (:Person {name: $name})", &params).await.unwrap();

    // Rollback
    conn.rollback().await.unwrap();

    // Verify person was not created
    let (page, _) = conn.query_with_params(
        "MATCH (p:Person {name: $name}) RETURN p",
        &params
    ).await.unwrap();
    assert_eq!(page.rows.len(), 0);
}

import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
import { GenericContainer, StartedTestContainer, Wait } from 'testcontainers';
import { createClient, GeodeClient } from '@geodedb/client';

describe('Geode Integration Tests', () => {
    let container: StartedTestContainer;
    let client: GeodeClient;

    beforeAll(async () => {
        container = await new GenericContainer('geodedb/geode:latest')
            .withExposedPorts(3141)
            .withCommand(['serve', '--listen', '0.0.0.0:3141'])
            .withWaitStrategy(Wait.forLogMessage('Server listening'))
            .start();

        const host = container.getHost();
        const port = container.getMappedPort(3141);
        client = await createClient(`quic://${host}:${port}`);
    }, 60000);

    afterAll(async () => {
        await client?.close();
        await container?.stop();
    });

    beforeEach(async () => {
        // Clean database before each test
        await client.exec('MATCH (n) DETACH DELETE n');
    });

    it('should create and query person', async () => {
        // Create person
        await client.exec(
            'CREATE (:Person {name: $name, age: $age})',
            { params: { name: 'Alice', age: 30 } }
        );

        // Query person
        const rows = await client.queryAll(
            'MATCH (p:Person {name: $name}) RETURN p.name, p.age',
            { params: { name: 'Alice' } }
        );

        expect(rows.length).toBe(1);
        expect(rows[0].get('p.name')?.asString).toBe('Alice');
        expect(rows[0].get('p.age')?.asNumber).toBe(30);
    });

    it('should create relationship', async () => {
        // Create nodes
        await client.exec('CREATE (:Person {name: $name})', { params: { name: 'Alice' } });
        await client.exec('CREATE (:Person {name: $name})', { params: { name: 'Bob' } });

        // Create relationship
        await client.exec(`
            MATCH (a:Person {name: $from}), (b:Person {name: $to})
            CREATE (a)-[:KNOWS {since: $since}]->(b)
        `, { params: { from: 'Alice', to: 'Bob', since: 2020 } });

        // Verify relationship
        const rows = await client.queryAll(`
            MATCH (a:Person)-[r:KNOWS]->(b:Person)
            RETURN a.name, b.name, r.since
        `);

        expect(rows.length).toBe(1);
        expect(rows[0].get('a.name')?.asString).toBe('Alice');
        expect(rows[0].get('b.name')?.asString).toBe('Bob');
        expect(rows[0].get('r.since')?.asNumber).toBe(2020);
    });

    it('should rollback transaction', async () => {
        await client.withTransaction(async (tx) => {
            // Create person
            await tx.exec('CREATE (:Person {name: $name})', { params: { name: 'Alice' } });

            // Throw to trigger rollback
            throw new Error('Intentional rollback');
        }).catch(() => {});

        // Verify person was not created
        const rows = await client.queryAll(
            'MATCH (p:Person {name: $name}) RETURN p',
            { params: { name: 'Alice' } }
        );
        expect(rows.length).toBe(0);
    });
});