fraiseql-core 2.2.0

Core execution engine for FraiseQL v2 - Compiled GraphQL over SQL
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

#![allow(clippy::unwrap_used)] // Reason: test code, panics are acceptable

//! Database failure injection tests.
//!
//! Tests error paths when the database adapter returns various failure types.

use fraiseql_core::{db::DatabaseAdapter, error::FraiseQLError};
use fraiseql_test_utils::failing_adapter::{FailError, FailingAdapter};
use serde_json::json;

#[tokio::test]
async fn test_query_returns_database_error_on_injected_failure() {
    let adapter = FailingAdapter::new().fail_on_query(0);

    let result = adapter.execute_where_query("v_user", None, None, None, None).await;

    assert!(result.is_err(), "expected Err from injected failure, got: {result:?}");
    let err = result.unwrap_err();
    assert!(
        matches!(err, FraiseQLError::Database { .. }),
        "expected Database error, got: {err:?}"
    );
    assert!(err.is_server_error());
}

#[tokio::test]
async fn test_second_query_fails_while_first_succeeds() {
    let adapter = FailingAdapter::new()
        .with_response("v_user", vec![fraiseql_core::db::types::JsonbValue::new(json!({"id": 1}))])
        .fail_on_query(1);

    // First query succeeds
    let result1 = adapter.execute_where_query("v_user", None, None, None, None).await;
    let rows = result1.unwrap_or_else(|e| panic!("expected Ok on first query: {e}"));
    assert_eq!(rows.len(), 1);

    // Second query fails
    let result2 = adapter.execute_where_query("v_user", None, None, None, None).await;
    assert!(
        result2.is_err(),
        "expected Err on second query (fail_on_query(1)), got: {result2:?}"
    );
}

#[tokio::test]
async fn test_timeout_error_contains_duration() {
    let adapter = FailingAdapter::new().fail_with_timeout(5000);

    let result = adapter.execute_where_query("v_user", None, None, None, None).await;

    let err = result.unwrap_err();
    match err {
        FraiseQLError::Timeout { timeout_ms, .. } => {
            assert_eq!(timeout_ms, 5000);
        },
        other => panic!("expected Timeout, got {other:?}"),
    }
}

#[tokio::test]
async fn test_connection_pool_error_is_retryable() {
    let adapter = FailingAdapter::new().fail_with_error(FailError::ConnectionPool {
        message: "pool exhausted".to_string(),
    });

    let result = adapter.execute_where_query("v_user", None, None, None, None).await;

    let err = result.unwrap_err();
    assert!(matches!(err, FraiseQLError::ConnectionPool { .. }));
    assert!(err.is_retryable());
}

#[tokio::test]
async fn test_health_check_failure() {
    let adapter = FailingAdapter::new().fail_health_check();

    let result = adapter.health_check().await;
    assert!(result.is_err(), "expected Err from failed health check, got: {result:?}");
    assert!(
        matches!(result.unwrap_err(), FraiseQLError::Database { .. }),
        "expected Database error from health check failure"
    );
}

#[tokio::test]
async fn test_query_log_records_all_attempts() {
    let adapter = FailingAdapter::new();

    let _ = adapter.execute_where_query("v_user", None, None, None, None).await;
    let _ = adapter.execute_where_query("v_post", None, None, None, None).await;
    let _ = adapter.execute_where_query("v_user", None, None, None, None).await;

    let log = adapter.recorded_queries();
    assert_eq!(log, vec!["v_user", "v_post", "v_user"]);
}

#[tokio::test]
async fn test_custom_error_propagation() {
    let adapter = FailingAdapter::new().fail_with_error(FailError::Cancelled {
        query_id: "q-123".to_string(),
        reason:   "client disconnect".to_string(),
    });

    let result = adapter.execute_where_query("v_user", None, None, None, None).await;

    let err = result.unwrap_err();
    match err {
        FraiseQLError::Cancelled { query_id, reason } => {
            assert_eq!(query_id, "q-123");
            assert_eq!(reason, "client disconnect");
        },
        other => panic!("expected Cancelled, got {other:?}"),
    }
}

#[tokio::test]
async fn test_error_classification_database_is_server_error() {
    let err = FraiseQLError::Database {
        message:   "connection refused".to_string(),
        sql_state: None,
    };
    assert!(err.is_server_error());
    assert!(!err.is_client_error());
    assert_eq!(err.status_code(), 500);
}

#[tokio::test]
async fn test_error_classification_timeout_is_retryable() {
    let err = FraiseQLError::Timeout {
        timeout_ms: 3000,
        query:      Some("SELECT 1".to_string()),
    };
    assert!(err.is_retryable());
    assert!(err.is_server_error());
    assert_eq!(err.status_code(), 408);
}

#[tokio::test]
async fn test_multiple_failures_then_recovery() {
    let adapter = FailingAdapter::new().fail_with_error(FailError::Database {
        message:   "temporary failure".to_string(),
        sql_state: None,
    });

    // Fails
    let result = adapter.execute_where_query("v_user", None, None, None, None).await;
    assert!(result.is_err(), "expected Err from injected database failure, got: {result:?}");

    // Reset clears failure
    adapter.reset();

    // Succeeds after reset
    let result = adapter.execute_where_query("v_user", None, None, None, None).await;
    result.unwrap_or_else(|e| panic!("expected Ok after reset: {e}"));
}