mod admin;
mod matcher;
mod query;
mod read;
mod rows;
mod rules;
mod schema;
mod server;
mod state;
mod write;
pub use matcher::BigQueryFakeQuery;
pub use rules::{
BigQueryFakeCode, BigQueryFakeFault, BigQueryFakeJobFailure, BigQueryFakeRpc, BigQueryFakeRule,
};
use crate::db::fake::FakeServer;
use crate::errors::BigQueryError;
use crate::query::{parameter_mode, ParamList};
use crate::read::BigQueryBatchRows;
use crate::testing::rows::ProtoBatchBuilder;
use crate::testing::rules::{
FaultRule, QueryAnswer, QueryMatcher, QueryReply, QueryRule, ReadRule, RejectRule,
ShownParameters,
};
use crate::testing::server::FakeShared;
use crate::testing::state::{DatasetKey, FakeTable, TableKey};
use crate::{
BigQueryChange, BigQueryDatasetRef, BigQueryDb, BigQueryDmlStats, BigQueryParamType,
BigQueryResult, BigQuerySchemaColumns, BigQuerySchemaColumnsBuilder, BigQuerySql,
BigQueryStatementType, BigQueryTableRef, BigQueryTableSchema,
};
use arrow_array::RecordBatch;
use serde::de::DeserializeOwned;
use serde::Serialize;
use std::fmt::{Debug, Formatter};
use std::num::NonZeroUsize;
use std::sync::Arc;
pub struct BigQueryFake {
db: BigQueryDb,
shared: Arc<FakeShared>,
_server: FakeServer,
}
impl Debug for BigQueryFake {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BigQueryFake")
.field("db", &self.db)
.finish_non_exhaustive()
}
}
impl BigQueryFake {
pub fn db(&self) -> &BigQueryDb {
&self.db
}
pub fn when_query_match(&self, sql: impl Into<BigQuerySql>) -> BigQueryFakeQueryBuilder<'_> {
let (sql, _) = sql.into().into_parts();
BigQueryFakeQueryBuilder::new(self, QueryMatcher::Exact(sql))
}
pub fn when_query<F>(&self, matcher: F) -> BigQueryFakeQueryBuilder<'_>
where
F: Fn(&BigQueryFakeQuery<'_>) -> bool + Send + Sync + 'static,
{
BigQueryFakeQueryBuilder::new(self, QueryMatcher::Matching(Box::new(matcher)))
}
pub fn create_dataset(&self, dataset: impl Into<BigQueryDatasetRef>) -> BigQueryResult<()> {
let key = DatasetKey::resolve(&dataset.into(), self.shared.project());
self.shared.state().create_dataset(key)?;
Ok(())
}
pub fn table<F, R>(
&self,
table: impl Into<BigQueryTableRef>,
columns: F,
) -> BigQueryFakeTableBuilder<'_>
where
F: FnOnce(BigQuerySchemaColumnsBuilder) -> R,
R: Into<BigQuerySchemaColumns>,
{
let contents = columns(BigQuerySchemaColumnsBuilder)
.into()
.table_schema()
.map(|schema| FakeTableContents {
schema,
batches: Vec::new(),
rows: 0,
});
BigQueryFakeTableBuilder {
fake: self,
table: table.into(),
contents,
read_streams: 1,
}
}
pub fn when_read(&self, table: impl Into<BigQueryTableRef>) -> BigQueryFakeReadBuilder<'_> {
BigQueryFakeReadBuilder {
fake: self,
table: table.into(),
row_restriction: None,
times: None,
}
}
pub fn when_fault(&self, rpc: BigQueryFakeRpc) -> BigQueryFakeFaultBuilder<'_> {
BigQueryFakeFaultBuilder {
fake: self,
rpc,
table: None,
times: None,
}
}
pub fn when_rows_rejected<T, F>(
&self,
table: impl Into<BigQueryTableRef>,
reason: impl Into<String>,
rejects: F,
) -> BigQueryFakeRule
where
T: DeserializeOwned + 'static,
F: Fn(&T) -> bool + Send + Sync + 'static,
{
let table = TableKey::resolve(&table.into(), self.shared.project());
let reason = reason.into();
let rule =
BigQueryFakeRule::unlimited(format!("when_rows_rejected on {table}: {reason:?}"));
self.shared.rules().add_rejection(RejectRule {
table,
reason,
rejects: Box::new(move |batch: &RecordBatch| {
let mut rejected = Vec::new();
for (index, row) in BigQueryBatchRows::<T>::new(batch).enumerate() {
if rejects(&row?) {
rejected.push(index);
}
}
Ok(rejected)
}),
rule: rule.clone(),
});
rule
}
pub fn rows<T: DeserializeOwned>(
&self,
table: impl Into<BigQueryTableRef>,
) -> BigQueryResult<Vec<T>> {
let key = TableKey::resolve(&table.into(), self.shared.project());
let batches = self.shared.state().table(&key)?.batches.clone();
let mut rows = Vec::new();
let mut first_row = 0;
for batch in &batches {
for row in BigQueryBatchRows::<T>::numbered_from(batch, first_row) {
rows.push(row?);
}
first_row += batch.num_rows() as u64;
}
Ok(rows)
}
pub fn changes<T: DeserializeOwned>(
&self,
table: impl Into<BigQueryTableRef>,
) -> BigQueryResult<Vec<BigQueryChange<T>>> {
let key = TableKey::resolve(&table.into(), self.shared.project());
let written = self.shared.state().table(&key)?.changes.clone();
let mut changes = Vec::new();
let mut first_row = 0;
for batch in &written {
let rows = BigQueryBatchRows::<T>::numbered_from(&batch.rows, first_row);
for (row, change) in rows.zip(&batch.changes) {
changes.push(BigQueryChange {
change_type: change.change_type,
sequence_number: change.sequence_number.clone(),
row: row?,
});
}
first_row += batch.rows.num_rows() as u64;
}
Ok(changes)
}
}
#[derive(Debug)]
#[must_use]
pub struct BigQueryFakeQueryBuilder<'a> {
fake: &'a BigQueryFake,
matcher: QueryMatcher,
parameters: ParamList,
times: Option<usize>,
bytes_processed: Option<i64>,
}
impl<'a> BigQueryFakeQueryBuilder<'a> {
fn new(fake: &'a BigQueryFake, matcher: QueryMatcher) -> Self {
Self {
fake,
matcher,
parameters: ParamList::default(),
times: None,
bytes_processed: None,
}
}
}
impl BigQueryFakeQueryBuilder<'_> {
pub fn param<N: Into<String>, V: Serialize>(mut self, name: N, value: V) -> Self {
self.parameters.named(&name.into(), &value);
self
}
pub fn param_as<N: Into<String>, V: Serialize>(
mut self,
name: N,
ty: impl Into<BigQueryParamType>,
value: V,
) -> Self {
self.parameters.named_as(&name.into(), &ty.into(), &value);
self
}
pub fn params<P: Serialize + ?Sized>(mut self, params: &P) -> Self {
self.parameters.fields(params);
self
}
pub fn positional_param<V: Serialize>(mut self, value: V) -> Self {
self.parameters.positional(&value);
self
}
pub fn positional_param_as<V: Serialize>(
mut self,
ty: impl Into<BigQueryParamType>,
value: V,
) -> Self {
self.parameters.positional_as(&ty.into(), &value);
self
}
pub fn times(mut self, calls: usize) -> Self {
self.times = Some(calls);
self
}
pub fn bytes_processed(mut self, bytes: i64) -> Self {
self.bytes_processed = Some(bytes);
self
}
pub fn returns_rows<F, R, T, I>(self, columns: F, rows: I) -> BigQueryResult<BigQueryFakeRule>
where
F: FnOnce(BigQuerySchemaColumnsBuilder) -> R,
R: Into<BigQuerySchemaColumns>,
I: IntoIterator<Item = T>,
T: Serialize,
{
let schema = columns(BigQuerySchemaColumnsBuilder)
.into()
.table_schema()?;
let rows = ProtoBatchBuilder::encode(&schema, rows, 0)?;
self.register(QueryAnswer::Rows { schema, rows })
}
pub fn returns_dml(
self,
statement_type: BigQueryStatementType,
stats: BigQueryDmlStats,
) -> BigQueryResult<BigQueryFakeRule> {
self.register(QueryAnswer::Dml {
statement_type,
stats,
})
}
pub fn returns_statement(
self,
statement_type: BigQueryStatementType,
) -> BigQueryResult<BigQueryFakeRule> {
self.register(QueryAnswer::Statement(statement_type))
}
pub fn fails(self, fault: BigQueryFakeFault) -> BigQueryResult<BigQueryFakeRule> {
self.register(QueryAnswer::Fault(fault))
}
pub fn fails_job(self, failure: BigQueryFakeJobFailure) -> BigQueryResult<BigQueryFakeRule> {
self.register(QueryAnswer::JobFailure(failure))
}
fn register(self, answer: QueryAnswer) -> BigQueryResult<BigQueryFakeRule> {
let parameters = self.parameters.into_parameters()?;
parameter_mode(¶meters)?;
let mut description = self.matcher.to_string();
if !parameters.is_empty() {
description.push_str(&format!(" with {}", ShownParameters(¶meters)));
}
let rule = BigQueryFakeRule::limited(description, self.times)?;
self.fake.shared.rules().add_query(QueryRule {
matcher: self.matcher,
parameters: (!parameters.is_empty()).then_some(parameters),
reply: Arc::new(QueryReply {
answer,
bytes_processed: self.bytes_processed,
}),
rule: rule.clone(),
});
Ok(rule)
}
}
#[derive(Debug)]
struct FakeTableContents {
schema: BigQueryTableSchema,
batches: Vec<RecordBatch>,
rows: u64,
}
#[derive(Debug)]
#[must_use]
pub struct BigQueryFakeTableBuilder<'a> {
fake: &'a BigQueryFake,
table: BigQueryTableRef,
contents: BigQueryResult<FakeTableContents>,
read_streams: usize,
}
impl BigQueryFakeTableBuilder<'_> {
pub fn rows<T: Serialize, I: IntoIterator<Item = T>>(mut self, rows: I) -> Self {
if let Ok(contents) = &mut self.contents {
match ProtoBatchBuilder::encode(&contents.schema, rows, contents.rows) {
Ok(batch) => {
contents.rows += batch.num_rows() as u64;
contents.batches.push(batch);
}
Err(failure) => self.contents = Err(failure),
}
}
self
}
pub fn read_streams(mut self, streams: usize) -> Self {
self.read_streams = streams;
self
}
pub fn create(self) -> BigQueryResult<()> {
let contents = self.contents?;
let read_streams = NonZeroUsize::new(self.read_streams).ok_or_else(|| {
BigQueryError::invalid_parameters(
"read_streams",
format!("{} would have no read stream; pass 1 or more", self.table),
)
})?;
let key = TableKey::resolve(&self.table, self.fake.shared.project());
let mut state = self.fake.shared.state();
let generation = state.next_generation();
let table = FakeTable::new(contents.schema, contents.batches, read_streams, generation);
state.create_table(key, table)
}
}
#[derive(Debug)]
#[must_use]
pub struct BigQueryFakeReadBuilder<'a> {
fake: &'a BigQueryFake,
table: BigQueryTableRef,
row_restriction: Option<String>,
times: Option<usize>,
}
impl BigQueryFakeReadBuilder<'_> {
pub fn row_restriction(mut self, restriction: impl Into<String>) -> Self {
self.row_restriction = Some(restriction.into());
self
}
pub fn times(mut self, calls: usize) -> Self {
self.times = Some(calls);
self
}
pub fn returns_rows<T: Serialize, I: IntoIterator<Item = T>>(
self,
rows: I,
) -> BigQueryResult<BigQueryFakeRule> {
let table = TableKey::resolve(&self.table, self.fake.shared.project());
let schema = self.fake.shared.state().table(&table)?.schema.clone();
let rows = ProtoBatchBuilder::encode(&schema, rows, 0)?;
let description = match &self.row_restriction {
Some(restriction) => format!("read of {table} where {restriction:?}"),
None => format!("read of {table}"),
};
let rule = BigQueryFakeRule::limited(description, self.times)?;
self.fake.shared.rules().add_read(ReadRule {
table,
row_restriction: self.row_restriction,
rows,
rule: rule.clone(),
});
Ok(rule)
}
}
#[derive(Debug)]
#[must_use]
pub struct BigQueryFakeFaultBuilder<'a> {
fake: &'a BigQueryFake,
rpc: BigQueryFakeRpc,
table: Option<BigQueryTableRef>,
times: Option<usize>,
}
impl BigQueryFakeFaultBuilder<'_> {
pub fn on_table(mut self, table: impl Into<BigQueryTableRef>) -> Self {
self.table = Some(table.into());
self
}
pub fn times(mut self, calls: usize) -> Self {
self.times = Some(calls);
self
}
pub fn fails(self, fault: BigQueryFakeFault) -> BigQueryResult<BigQueryFakeRule> {
let rpc = self.rpc;
let table = self
.table
.map(|table| TableKey::resolve(&table, self.fake.shared.project()));
if table.is_some() && !rpc.names_a_table() {
return Err(BigQueryError::invalid_parameters(
"on_table",
format!("{rpc:?} calls name no table"),
));
}
let description = match &table {
Some(table) => format!("fault on {rpc:?} of {table}"),
None => format!("fault on {rpc:?}"),
};
let rule = BigQueryFakeRule::limited(description, self.times)?;
self.fake.shared.rules().add_fault(FaultRule {
rpc,
table,
fault,
rule: rule.clone(),
});
Ok(rule)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::BigQueryDatasetId;
use serde::Deserialize;
use std::panic::{catch_unwind, AssertUnwindSafe};
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct Order {
id: i64,
customer: String,
total: f64,
paid: bool,
receipt: Option<Vec<u8>>,
}
const ORDERS_OF: &str =
"SELECT id, customer, total, paid, receipt FROM shop.orders WHERE customer = @customer";
fn paid(id: i64, customer: &str, total: f64, receipt: &[u8]) -> Order {
Order {
id,
customer: customer.to_string(),
total,
paid: true,
receipt: Some(receipt.to_vec()),
}
}
fn unpaid(id: i64, customer: &str, total: f64) -> Order {
Order {
id,
customer: customer.to_string(),
total,
paid: false,
receipt: None,
}
}
async fn orders_of(db: &BigQueryDb, customer: &str) -> BigQueryResult<Vec<Order>> {
db.fluent()
.query(ORDERS_OF)
.param("customer", customer)
.obj()
.query()
.await
}
fn drop_panics(fake: BigQueryFake) -> bool {
catch_unwind(AssertUnwindSafe(move || drop(fake))).is_err()
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn spawned_tasks_share_one_fake() -> BigQueryResult<()> {
let fake = Arc::new(BigQueryFake::start().await?);
let orders = vec![unpaid(1, "Alice", 12.0)];
let rule = fake
.when_query_match(ORDERS_OF)
.returns_rows(|columns| columns.from_type::<Order>(), &orders)?;
let spawned = tokio::spawn({
let fake = Arc::clone(&fake);
async move {
fake.db()
.fluent()
.query(ORDERS_OF)
.param("customer", "Alice")
.obj::<Order>()
.query()
.await
}
});
assert_eq!(spawned.await.expect("the task panicked")?, orders);
assert_eq!(rule.calls(), 1);
Ok(())
}
#[tokio::test]
async fn a_rule_answers_its_query_inline() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
let orders = vec![
paid(1, "Alice", 120.0, &[0, 159, 255]),
unpaid(2, "Alice", -0.5),
];
let rule = fake
.when_query_match(ORDERS_OF)
.returns_rows(|columns| columns.from_type::<Order>(), &orders)?;
let (rows, stats) = fake
.db()
.fluent()
.query(ORDERS_OF)
.param("customer", "Alice")
.obj::<Order>()
.query_with_stats()
.await?;
assert_eq!(rows, orders);
assert_eq!(stats.total_rows, Some(2));
assert_eq!(stats.statement_type, Some(BigQueryStatementType::Select));
assert_eq!(rule.calls(), 1);
Ok(())
}
#[tokio::test]
async fn an_unmatched_query_fails_verify() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
fake.when_query_match("SELECT 1")
.returns_rows(|columns| columns.from_type::<Order>(), Vec::<Order>::new())?;
let unmatched = orders_of(fake.db(), "Alice").await;
match &unmatched {
Err(BigQueryError::DatabaseError(err)) => {
assert_eq!(err.public.code, "Unimplemented");
assert!(!err.retry_possible);
}
other => panic!("expected the unmatched call to fail, got {other:?}"),
}
assert!(catch_unwind(AssertUnwindSafe(|| fake.verify())).is_err());
assert!(drop_panics(fake));
Ok(())
}
#[tokio::test]
async fn a_times_rule_not_used_up_fails_verify() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
let orders = vec![unpaid(1, "Alice", 120.0)];
let rule = fake
.when_query_match(ORDERS_OF)
.times(2)
.returns_rows(|columns| columns.from_type::<Order>(), &orders)?;
assert_eq!(orders_of(fake.db(), "Alice").await?, orders);
assert_eq!(rule.calls(), 1);
assert!(drop_panics(fake));
Ok(())
}
#[tokio::test]
async fn params_must_match_once_declared() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
let alice = vec![unpaid(1, "Alice", 120.0)];
let anyone = vec![paid(2, "Bob", 80.5, b"r-2"), unpaid(3, "Carol", 7.0)];
let for_alice = fake
.when_query_match(ORDERS_OF)
.param("customer", "Alice")
.returns_rows(|columns| columns.from_type::<Order>(), &alice)?;
let for_anyone = fake
.when_query_match(ORDERS_OF)
.returns_rows(|columns| columns.from_type::<Order>(), &anyone)?;
assert_eq!(orders_of(fake.db(), "Bob").await?, anyone);
assert_eq!(orders_of(fake.db(), "Alice").await?, alice);
assert_eq!((for_alice.calls(), for_anyone.calls()), (1, 1));
Ok(())
}
#[tokio::test]
async fn creating_a_dataset_that_exists_is_a_data_conflict() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
const SHOP: BigQueryDatasetId = BigQueryDatasetId::from_static("shop");
fake.create_dataset(SHOP)?;
let again = fake.create_dataset(SHOP);
assert!(
matches!(again, Err(BigQueryError::DataConflictError(_))),
"{again:?}"
);
Ok(())
}
#[tokio::test]
async fn a_rule_mixing_named_and_positional_parameters_is_refused() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
let registered = fake
.when_query_match(ORDERS_OF)
.param("customer", "Alice")
.positional_param(1)
.returns_rows(|columns| columns.from_type::<Order>(), Vec::<Order>::new());
match registered {
Err(BigQueryError::InvalidParametersError(err)) => {
assert_eq!(err.public.field, "query_parameters");
}
other => panic!("expected the rule to be refused, got {other:?}"),
}
Ok(())
}
#[tokio::test]
async fn named_parameters_must_equal_the_rule_as_a_set() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
fake.when_query_match(ORDERS_OF)
.param("customer", "Alice")
.param("customer", "Alice")
.returns_rows(|columns| columns.from_type::<Order>(), Vec::<Order>::new())?;
let unmatched: BigQueryResult<Vec<Order>> = fake
.db()
.fluent()
.query(ORDERS_OF)
.param("customer", "Alice")
.param("since", 2020)
.obj()
.query()
.await;
match &unmatched {
Err(BigQueryError::DatabaseError(err)) => assert_eq!(err.public.code, "Unimplemented"),
other => panic!("expected the call to go unmatched, got {other:?}"),
}
assert!(drop_panics(fake));
Ok(())
}
fn assert_unmatched<T: Debug>(call: &BigQueryResult<T>) {
match call {
Err(BigQueryError::DatabaseError(err)) => assert_eq!(err.public.code, "Unimplemented"),
other => panic!("expected the call to go unmatched, got {other:?}"),
}
}
#[tokio::test]
async fn a_when_query_matcher_sees_the_sql_and_a_named_param() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
let alice = vec![unpaid(1, "Alice", 120.0)];
let rule = fake
.when_query(|query| {
query.sql() == ORDERS_OF
&& query.param::<String>("customer").as_deref() == Some("Alice")
})
.returns_rows(|columns| columns.from_type::<Order>(), &alice)?;
assert_eq!(orders_of(fake.db(), "Alice").await?, alice);
assert_unmatched(&orders_of(fake.db(), "Bob").await);
assert_eq!(rule.calls(), 1);
assert!(drop_panics(fake));
Ok(())
}
#[tokio::test]
async fn a_when_query_matcher_reads_param_names_ignoring_case() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
let alice = vec![unpaid(1, "Alice", 120.0)];
let rule = fake
.when_query(|query| query.param::<String>("CUSTOMER").as_deref() == Some("Alice"))
.returns_rows(|columns| columns.from_type::<Order>(), &alice)?;
assert_eq!(orders_of(fake.db(), "Alice").await?, alice);
assert_eq!(rule.calls(), 1);
Ok(())
}
#[tokio::test]
async fn a_when_query_matcher_sees_a_positional_param() -> BigQueryResult<()> {
const ORDER_BY_ID: &str =
"SELECT id, customer, total, paid, receipt FROM shop.orders WHERE id = ?";
let fake = BigQueryFake::start().await?;
let second = vec![unpaid(2, "Bob", 80.5)];
let rule = fake
.when_query(|query| query.positional_param::<i64>(0) == Some(2))
.returns_rows(|columns| columns.from_type::<Order>(), &second)?;
let order_by_id = |id: i64| {
fake.db()
.fluent()
.query(ORDER_BY_ID)
.positional_param(id)
.obj::<Order>()
.query()
};
assert_eq!(order_by_id(2).await?, second);
assert_unmatched(&order_by_id(3).await);
assert_eq!(rule.calls(), 1);
assert!(drop_panics(fake));
Ok(())
}
#[tokio::test]
async fn a_named_param_that_does_not_decode_as_t_is_none() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
let rule = fake
.when_query(|query| query.param::<i64>("customer").is_some())
.returns_rows(|columns| columns.from_type::<Order>(), Vec::<Order>::new())?;
assert_unmatched(&orders_of(fake.db(), "Alice").await);
assert_eq!(rule.calls(), 0);
assert!(drop_panics(fake));
Ok(())
}
#[tokio::test]
async fn param_decodes_array_struct_and_range_values() -> BigQueryResult<()> {
use crate::{BigQueryDate, BigQueryRange};
use std::sync::Mutex;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
struct Filter {
customer: String,
since: BigQueryDate,
tags: Vec<String>,
}
const FILTERED: &str = "SELECT id FROM shop.orders \
WHERE id IN UNNEST(@ids) AND customer = @filter.customer AND day <@ @days";
let day = |day: i8| BigQueryDate(jiff::civil::date(2024, 3, day));
let ids = vec![1_i64, 2, 3];
let filter = Filter {
customer: "Alice".into(),
since: day(1),
tags: vec!["vip".into(), "eu".into()],
};
let days = BigQueryRange {
start: Some(day(1)),
end: None,
};
type Seen = (
Option<Vec<i64>>,
Option<Filter>,
Option<BigQueryRange<BigQueryDate>>,
);
let fake = BigQueryFake::start().await?;
let seen: Arc<Mutex<Option<Seen>>> = Arc::default();
let recorded = seen.clone();
fake.when_query(move |query| {
*recorded.lock().expect("no test thread panics holding it") = Some((
query.param("ids"),
query.param("filter"),
query.param("days"),
));
true
})
.returns_statement(BigQueryStatementType::Select)?;
fake.db()
.fluent()
.query(FILTERED)
.param("ids", &ids)
.param("filter", &filter)
.param("days", days)
.execute()
.await?;
let seen = seen
.lock()
.expect("no test thread panics holding it")
.take();
assert_eq!(seen, Some((Some(ids), Some(filter), Some(days))));
Ok(())
}
#[tokio::test]
async fn param_narrows_a_when_query_matcher() -> BigQueryResult<()> {
let fake = BigQueryFake::start().await?;
let alice = vec![unpaid(1, "Alice", 120.0)];
let rule = fake
.when_query(|query| query.sql().starts_with("SELECT"))
.param("customer", "Alice")
.returns_rows(|columns| columns.from_type::<Order>(), &alice)?;
assert_eq!(orders_of(fake.db(), "Alice").await?, alice);
assert_unmatched(&orders_of(fake.db(), "Bob").await);
assert_eq!(rule.calls(), 1);
assert!(drop_panics(fake));
Ok(())
}
}