use crate::common::{CompiledTest, FeatureCombination, invoke_and_capture_output};
use camino::Utf8Path;
use test_r::{test, test_dep};
use wasmtime::component::Val;
#[test_dep(tagged_as = "sqlite", scope = Cloneable)]
async fn compiled_sqlite() -> CompiledTest {
let path = Utf8Path::new("examples/runtime/sqlite");
CompiledTest::new_with_features(path, true, FeatureCombination::Full)
.await
.expect("Failed to compile sqlite")
}
#[test_dep(tagged_as = "sqlite_unoptimized", scope = Cloneable)]
async fn compiled_sqlite_unoptimized() -> CompiledTest {
let path = Utf8Path::new("examples/runtime/sqlite");
CompiledTest::new_unoptimized_with_features(path, true, FeatureCombination::Full)
.await
.expect("Failed to compile sqlite without Wizer")
}
#[test]
async fn sqlite_test_memory_roundtrip(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-memory-roundtrip",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_file_roundtrip(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) =
invoke_and_capture_output(compiled_test.wasm_path(), None, "test-file-roundtrip", &[])
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_udf_survives_restore(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-udf-survives-restore",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_constructor_overwritten(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-constructor-overwritten",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_open_transaction_detected(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-open-transaction-detected",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_read_only_rejected(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-read-only-rejected",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_wal_mode_snapshot(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-wal-mode-snapshot",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_autocommit_tracking(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-autocommit-tracking",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_type_validation(
#[tagged_as("sqlite")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) =
invoke_and_capture_output(compiled_test.wasm_path(), None, "test-type-validation", &[])
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}
#[test]
async fn sqlite_test_memory_roundtrip_unoptimized(
#[tagged_as("sqlite_unoptimized")] compiled_test: &CompiledTest,
) -> anyhow::Result<()> {
let (r, output) = invoke_and_capture_output(
compiled_test.wasm_path(),
None,
"test-memory-roundtrip",
&[],
)
.await;
let r = r?;
println!("Output:\n{}", output);
assert_eq!(r, Some(Val::Bool(true)));
Ok(())
}