use crate::db::fake::{FakeCall, FakeServer};
use crate::db::RetryBackoff;
use crate::errors::BigQueryError;
use crate::testing::rules::{BigQueryFakeFault, BigQueryFakeRpc, FakeRules};
use crate::testing::state::{FakeState, TableKey};
use crate::testing::BigQueryFake;
use crate::{BigQueryDbOptions, BigQueryResult};
use gcloud_sdk::prost::Message;
use gcloud_sdk::tonic::{Code, Status};
use std::fmt::{Display, Formatter};
use std::sync::{Arc, Mutex, MutexGuard, PoisonError};
const FAKE_PROJECT: &str = "fake-project";
pub(super) struct FakeShared {
project: String,
state: Mutex<FakeState>,
rules: Mutex<FakeRules>,
problems: Mutex<Vec<FakeProblem>>,
}
#[derive(Debug)]
enum FakeProblem {
Unmatched(String),
Internal(String),
}
pub(super) enum FakeRefusal {
Status(Status),
Internal(String),
}
impl From<Status> for FakeRefusal {
fn from(status: Status) -> Self {
Self::Status(status)
}
}
impl FakeShared {
fn new(project: String) -> Self {
Self {
project,
state: Mutex::default(),
rules: Mutex::default(),
problems: Mutex::default(),
}
}
pub(super) fn project(&self) -> &str {
&self.project
}
pub(super) fn state(&self) -> MutexGuard<'_, FakeState> {
self.state.lock().unwrap_or_else(PoisonError::into_inner)
}
pub(super) fn rules(&self) -> MutexGuard<'_, FakeRules> {
self.rules.lock().unwrap_or_else(PoisonError::into_inner)
}
fn problems(&self) -> MutexGuard<'_, Vec<FakeProblem>> {
self.problems.lock().unwrap_or_else(PoisonError::into_inner)
}
pub(super) async fn first_request<M: Message + Default>(
&self,
mut call: FakeCall,
) -> Option<(FakeCall, M)> {
match call.try_next_request::<M>().await {
Ok(Some(request)) => Some((call, request)),
Ok(None) => {
let described = format!("{} without a request message", call.method());
self.unmatched(call, &described, &[]);
None
}
Err(error) => {
let described = format!("{} whose request does not decode: {error}", call.method());
self.unmatched(call, &described, &[]);
None
}
}
}
pub(super) async fn unfaulted(
&self,
call: FakeCall,
rpc: BigQueryFakeRpc,
table: Option<&TableKey>,
) -> Option<FakeCall> {
let fault = self.rules().answer_fault(rpc, table);
match fault {
Some(fault) => {
fault.answer(call).await;
None
}
None => Some(call),
}
}
pub(super) fn unmatched(&self, call: FakeCall, described: &str, rules: &[String]) {
let rules = if rules.is_empty() {
"none".to_string()
} else {
rules.join("; ")
};
let problem = format!("no rule answers {described}; rules: {rules}");
let message = format!("bigquery fake: {problem}");
self.problems().push(FakeProblem::Unmatched(problem));
call.fail(Code::Unimplemented, &message);
}
pub(super) fn internal(&self, call: FakeCall, failure: &str) {
self.problems()
.push(FakeProblem::Internal(failure.to_string()));
call.fail(Code::Internal, &format!("bigquery fake: {failure}"));
}
pub(super) fn answer<M: Message>(&self, call: FakeCall, answer: Result<M, FakeRefusal>) {
match answer {
Ok(message) => call.reply(&message),
Err(FakeRefusal::Status(status)) => call.fail(status.code(), status.message()),
Err(FakeRefusal::Internal(failure)) => self.internal(call, &failure),
}
}
fn report(&self) -> FakeReport {
let mut lines: Vec<String> = self
.problems()
.iter()
.map(|problem| match problem {
FakeProblem::Unmatched(problem) => problem.clone(),
FakeProblem::Internal(failure) => format!("internal failure: {failure}"),
})
.collect();
lines.extend(self.rules().shortfalls());
FakeReport { lines }
}
}
impl BigQueryFakeFault {
pub(super) async fn answer(self, call: FakeCall) {
match self {
BigQueryFakeFault::Status { code, message } => call.fail(code.grpc_code(), &message),
BigQueryFakeFault::ConnectionDropped => call.drop_connection().await,
BigQueryFakeFault::Hang => call.hang().await,
}
}
}
struct FakeReport {
lines: Vec<String>,
}
impl Display for FakeReport {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "bigquery fake: {} problem(s):", self.lines.len())?;
for line in &self.lines {
write!(f, "\n - {line}")?;
}
Ok(())
}
}
impl FakeShared {
async fn dispatch(self: Arc<Self>, call: FakeCall) {
match call.method() {
"Query" | "InsertJob" | "GetQueryResults" | "GetJob" | "CancelJob" => {
self.serve_query(call).await;
}
"CreateReadSession" | "ReadRows" => self.serve_read(call).await,
"GetWriteStream"
| "CreateWriteStream"
| "AppendRows"
| "FlushRows"
| "FinalizeWriteStream"
| "BatchCommitWriteStreams" => self.serve_write(call).await,
"GetTable" | "InsertTable" | "PatchTable" | "UpdateTable" | "DeleteTable"
| "ListTables" | "GetDataset" | "InsertDataset" | "UpdateDataset" | "DeleteDataset"
| "ListDatasets" => self.serve_admin(call).await,
method => {
let described = method.to_string();
self.unmatched(call, &described, &[]);
}
}
}
}
impl BigQueryFake {
pub async fn start() -> BigQueryResult<Self> {
Self::start_with(BigQueryDbOptions::new(FAKE_PROJECT.to_string())).await
}
pub async fn start_with(options: BigQueryDbOptions) -> BigQueryResult<Self> {
let shared = Arc::new(FakeShared::new(options.google_project_id.clone()));
let served = shared.clone();
let server = FakeServer::bind(move |call| served.clone().dispatch(call))
.await
.map_err(|err| {
BigQueryError::system(
"FAKE_SERVER_UNAVAILABLE",
format!("the BigQuery fake cannot bind a loopback port: {err}"),
)
})?;
let db = server.client(options, RetryBackoff::Immediate).await?;
Ok(Self {
db,
shared,
_server: server,
})
}
pub fn verify(&self) {
let report = self.shared.report();
if !report.lines.is_empty() {
panic!("{report}");
}
}
}
impl Drop for BigQueryFake {
fn drop(&mut self) {
if std::thread::panicking() {
let report = self.shared.report();
if !report.lines.is_empty() {
tracing::error!(%report, "The BigQuery fake was dropped during a panic");
}
} else {
self.verify();
}
}
}