#![allow(clippy::unwrap_used, clippy::panic)]
#[test]
fn database_adapter_is_send_sync() {
fn assert_send_sync<T: Send + Sync + ?Sized>() {}
assert_send_sync::<dyn super::DatabaseAdapter>();
}
#[cfg(test)]
mod trait_defaults {
use std::collections::HashMap;
use async_trait::async_trait;
use fraiseql_error::Result;
use futures::StreamExt as _;
use serde_json::json;
use crate::{
dialect::RowViewColumnType,
traits::{DatabaseAdapter, ProjectionRequest},
types::{
ColumnSpec, ColumnValue, DatabaseType, JsonbValue, PoolMetrics, ReadRouting,
sql_hints::OrderByClause,
},
where_clause::WhereClause,
};
struct CollectOnlyAdapter {
rows: Vec<JsonbValue>,
}
#[async_trait]
impl DatabaseAdapter for CollectOnlyAdapter {
fn applies_session_variables(&self) -> bool {
true
}
async fn execute_where_query(
&self,
_view: &str,
_where_clause: Option<&WhereClause>,
_limit: Option<u32>,
_offset: Option<u32>,
_order_by: Option<&[OrderByClause]>,
) -> Result<Vec<JsonbValue>> {
Ok(self.rows.clone())
}
async fn execute_with_projection(
&self,
_view: &str,
_projection: Option<&crate::types::sql_hints::SqlProjectionHint>,
_where_clause: Option<&WhereClause>,
_limit: Option<u32>,
_offset: Option<u32>,
_order_by: Option<&[OrderByClause]>,
) -> Result<Vec<JsonbValue>> {
Ok(self.rows.clone())
}
fn database_type(&self) -> DatabaseType {
DatabaseType::PostgreSQL
}
async fn health_check(&self) -> Result<()> {
Ok(())
}
fn pool_metrics(&self) -> PoolMetrics {
PoolMetrics {
total_connections: 0,
idle_connections: 0,
active_connections: 0,
waiting_requests: 0,
}
}
async fn execute_raw_query(
&self,
_sql: &str,
) -> Result<Vec<HashMap<String, serde_json::Value>>> {
Ok(vec![
HashMap::from([("id".to_string(), json!(1))]),
HashMap::from([("id".to_string(), json!(2))]),
])
}
async fn execute_parameterized_aggregate(
&self,
_sql: &str,
_params: &[serde_json::Value],
) -> Result<Vec<HashMap<String, serde_json::Value>>> {
Ok(Vec::new())
}
}
#[tokio::test]
async fn projection_default_streams_the_collected_rows_in_order() {
let adapter = CollectOnlyAdapter {
rows: vec![
JsonbValue::new(json!({"id": 1})),
JsonbValue::new(json!({"id": 2})),
JsonbValue::new(json!({"id": 3})),
],
};
let stream = adapter
.stream_with_projection(&ProjectionRequest::new("v_user"), &[], ReadRouting::Any)
.await
.expect("default streaming read");
let got: Vec<_> = stream.map(|r| r.expect("row").into_value()).collect().await;
assert_eq!(got, vec![json!({"id": 1}), json!({"id": 2}), json!({"id": 3})]);
}
#[tokio::test]
async fn row_query_default_streams_the_collected_rows_in_order() {
let adapter = CollectOnlyAdapter { rows: Vec::new() };
let columns = [ColumnSpec {
name: "id".to_string(),
column_type: RowViewColumnType::Int64,
}];
let stream = adapter
.stream_row_query("v_user", &columns, None, None, None, None)
.await
.expect("default streaming row read");
let got: Vec<_> = stream.map(|r| r.expect("row")).collect().await;
let ids: Vec<i64> = got
.iter()
.map(|row| match row.as_slice() {
[ColumnValue::Int64(id)] => *id,
other => panic!("expected one Int64 column, got {other:?}"),
})
.collect();
assert_eq!(ids, vec![1, 2]);
}
}
#[cfg(test)]
mod row_query_sql {
use crate::traits::build_row_query_sql;
#[test]
fn renders_every_clause_in_sql_order() {
assert_eq!(
build_row_query_sql(
"v_user",
Some("data->>'x' = '1'"),
Some("id ASC"),
Some(10),
Some(5)
),
"SELECT * FROM \"v_user\" WHERE data->>'x' = '1' ORDER BY id ASC LIMIT 10 OFFSET 5"
);
}
#[test]
fn omits_absent_clauses() {
assert_eq!(
build_row_query_sql("v_user", None, None, None, None),
"SELECT * FROM \"v_user\""
);
}
}
#[test]
fn take_matched_strips_the_count_and_the_empty_marker() {
use serde_json::json;
use super::{EMPTY_PAGE_KEY, JsonbValue, MATCHED_KEY, take_matched};
let page = [
JsonbValue::new(json!({ "id": 1, MATCHED_KEY: 7 })),
JsonbValue::new(json!({ "id": 2, MATCHED_KEY: 7 })),
];
let (rows, matched) = take_matched(&page);
assert_eq!(matched, Some(7));
let rows: Vec<_> = rows.iter().map(|r| r.data.clone()).collect();
assert_eq!(rows, [json!({ "id": 1 }), json!({ "id": 2 })]);
let empty = [JsonbValue::new(
json!({ EMPTY_PAGE_KEY: true, MATCHED_KEY: 4 }),
)];
let (rows, matched) = take_matched(&empty);
assert!(rows.is_empty());
assert_eq!(matched, Some(4));
let plain = [JsonbValue::new(json!({ "id": 1 }))];
assert_eq!(take_matched(&plain).1, None);
}
#[test]
fn a_report_reads_as_the_rows_it_names_and_the_types_it_truncated() {
let report = serde_json::json!({
"updated": [{"__typename": "User", "id": "a"}, {"__typename": "Tag", "id": 7}],
"deleted": [{"__typename": "User", "id": "b"}, {"__typename": "Post", "id": null}],
"invalidated_types": ["Comment"],
"truncated": true,
});
let changed = super::ChangedRows::from_report(&report).unwrap();
let ids = |t: &str| changed.rows.get(t).map(|ids| ids.iter().cloned().collect::<Vec<_>>());
assert_eq!(ids("User"), Some(vec!["a".to_string(), "b".to_string()]));
assert_eq!(ids("Tag"), Some(vec!["7".to_string()]));
assert_eq!(ids("Post"), None);
assert_eq!(
changed.types.iter().cloned().collect::<Vec<_>>(),
["Comment".to_string(), "Post".to_string()]
);
}
#[test]
fn what_is_not_a_report_reads_as_unknown() {
for report in [
serde_json::json!(null),
serde_json::json!([]),
serde_json::json!({"updated": "User"}),
serde_json::json!({"updated": [{"id": "a"}]}),
serde_json::json!({"invalidated_types": [1]}),
] {
assert_eq!(super::ChangedRows::from_report(&report), None, "{report}");
}
assert_eq!(
super::ChangedRows::from_report(&serde_json::json!({})),
Some(super::ChangedRows {
collections: None,
..super::ChangedRows::default()
}),
"a report of nothing changed, which captured no collections"
);
}
#[test]
fn a_report_reads_as_the_collections_it_names() {
let report = serde_json::json!({
"updated": [{"__typename": "Comment", "id": "c1"}],
"collections": {"Comment.fk_post": ["p2", "p1"], "Tag.fk_post": [7]},
});
let changed = super::ChangedRows::from_report(&report).unwrap();
let collections = changed.collections.expect("captured");
let parents =
|key: &str| collections.get(key).map(|ids| ids.iter().cloned().collect::<Vec<_>>());
assert_eq!(parents("Comment.fk_post"), Some(vec!["p1".to_string(), "p2".to_string()]));
assert_eq!(parents("Tag.fk_post"), Some(vec!["7".to_string()]));
assert!(changed.types.is_empty());
}
#[test]
fn a_report_without_collections_captured_none() {
let report = serde_json::json!({"updated": [{"__typename": "Comment", "id": "c1"}]});
let changed = super::ChangedRows::from_report(&report).unwrap();
assert_eq!(changed.collections, None);
assert!(changed.rows.contains_key("Comment"), "the rows are read all the same");
}
#[test]
fn an_unreadable_collection_evicts_more_never_less() {
let report = serde_json::json!({"collections": {"Comment.fk_post": ["p1", {"x": 1}]}});
let changed = super::ChangedRows::from_report(&report).unwrap();
assert!(changed.types.contains("Comment"), "{changed:?}");
for report in [
serde_json::json!({"collections": {"Comment": ["p1"]}}),
serde_json::json!({"collections": {".fk_post": ["p1"]}}),
serde_json::json!({"collections": {"Comment.": ["p1"]}}),
] {
let changed = super::ChangedRows::from_report(&report).unwrap();
assert_eq!(changed.collections, None, "{report}");
}
for report in [
serde_json::json!({"collections": ["Comment.fk_post"]}),
serde_json::json!({"collections": {"Comment.fk_post": "p1"}}),
] {
assert_eq!(super::ChangedRows::from_report(&report), None, "{report}");
}
}
#[test]
fn absorbed_reports_name_their_collections_together_or_none() {
let read = |report: serde_json::Value| super::ChangedRows::from_report(&report).unwrap();
let mut all = super::ChangedRows::default();
all.absorb(read(serde_json::json!({"collections": {"Comment.fk_post": ["p1"]}})));
all.absorb(read(serde_json::json!({"collections": {"Comment.fk_post": ["p2"]}})));
let parents = all.collections.clone().unwrap()["Comment.fk_post"].len();
assert_eq!(parents, 2, "{all:?}");
all.absorb(read(serde_json::json!({"updated": []})));
assert_eq!(all.collections, None, "a call that captured none");
all.absorb(read(serde_json::json!({"collections": {"Comment.fk_post": ["p3"]}})));
assert_eq!(all.collections, None, "stays unknown");
}
#[test]
fn the_default_is_a_write_that_changed_nothing() {
let nothing = super::ChangedRows::default();
assert!(nothing.rows.is_empty() && nothing.types.is_empty());
assert_eq!(nothing.collections, Some(std::collections::BTreeMap::new()));
}