chore(outbound-pg): Add basic integration test

Signed-off-by: Konstantin Shabanov <[email protected]>

Author: etehtsea

Cargo.toml

@@ -84,6 +84,7 @@ default = []
 e2e-tests = []
 outbound-redis-tests = []
 config-provider-tests = []
+outbound-pg-tests = []
 
 [workspace]
 members = [

Makefile

@@ -41,6 +41,10 @@ test-outbound-redis:
 test-config-provider:
 	RUST_LOG=$(LOG_LEVEL) cargo test --test integration --features config-provider-tests --no-fail-fast -- integration_tests::config_provider_tests --nocapture
 
+.PHONY: test-outbound-pg
+test-outbound-pg:
+	RUST_LOG=$(LOG_LEVEL) cargo test --test integration --features outbound-pg-tests --no-fail-fast -- --nocapture
+
 .PHONY: test-sdk-go
 test-sdk-go:
 	$(MAKE) -C sdk/go test

build.rs

@@ -11,6 +11,7 @@ const RUST_HTTP_INTEGRATION_TEST: &str = "tests/http/simple-spin-rust";
 const RUST_HTTP_INTEGRATION_ENV_TEST: &str = "tests/http/headers-env-routes-test";
 const RUST_HTTP_VAULT_CONFIG_TEST: &str = "tests/http/vault-config-test";
 const RUST_OUTBOUND_REDIS_INTEGRATION_TEST: &str = "tests/outbound-redis/http-rust-outbound-redis";
+const RUST_OUTBOUND_PG_INTEGRATION_TEST: &str = "tests/outbound-pg/http-rust-outbound-pg";
 
 fn main() {
     let mut config = vergen::Config::default();
@@ -72,6 +73,7 @@ error: the `wasm32-wasi` target is not installed
     cargo_build(RUST_HTTP_INTEGRATION_ENV_TEST);
     cargo_build(RUST_HTTP_VAULT_CONFIG_TEST);
     cargo_build(RUST_OUTBOUND_REDIS_INTEGRATION_TEST);
+    cargo_build(RUST_OUTBOUND_PG_INTEGRATION_TEST);
 }
 
 fn build_wasm_test_program(name: &'static str, root: &'static str) {

tests/integration.rs

@@ -604,7 +604,7 @@ mod integration_tests {
     }
 
     #[cfg(feature = "outbound-redis-tests")]
-    mod outbound_pg_tests {
+    mod outbound_redis_tests {
         use super::*;
 
         const RUST_OUTBOUND_REDIS_INTEGRATION_TEST: &str =
@@ -649,6 +649,32 @@ mod integration_tests {
         Ok(())
     }
 
+    #[cfg(feature = "outbound-pg-tests")]
+    mod outbound_pg_tests {
+        use super::*;
+
+        const RUST_OUTBOUND_PG_INTEGRATION_TEST: &str = "tests/outbound-pg/http-rust-outbound-pg";
+
+        #[tokio::test]
+        async fn test_outbound_pg_rust_local() -> Result<()> {
+            let s = SpinTestController::with_manifest(
+                &format!(
+                    "{}/{}",
+                    RUST_OUTBOUND_PG_INTEGRATION_TEST, DEFAULT_MANIFEST_LOCATION
+                ),
+                &[],
+                &[],
+                None,
+            )
+            .await?;
+
+            assert_status(&s, "/test_read_types", 200).await?;
+            assert_status(&s, "/pg_backend_pid", 200).await?;
+
+            Ok(())
+        }
+    }
+
     #[tokio::test]
     async fn test_static_assets_without_bindle() -> Result<()> {
         let s = SpinTestController::with_manifest(

tests/outbound-pg/http-rust-outbound-pg/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+target = "wasm32-wasi"

tests/outbound-pg/http-rust-outbound-pg/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "http-rust-outbound-pg"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = [ "cdylib" ]
+
+[dependencies]
+# Useful crate to handle errors.
+anyhow = "1"
+# Crate to simplify working with bytes.
+bytes = "1"
+# General-purpose crate with common HTTP types.
+http = "0.2"
+# The Spin SDK.
+spin-sdk = { path = "../../../sdk/rust" }
+# Crate that generates Rust Wasm bindings from a WebAssembly interface.
+wit-bindgen-rust = { git = "https://github.com/bytecodealliance/wit-bindgen", rev = "cb871cfa1ee460b51eb1d144b175b9aab9c50aba" }
+
+[workspace]

tests/outbound-pg/http-rust-outbound-pg/spin.toml

@@ -0,0 +1,14 @@
+spin_version = "1"
+authors = ["Fermyon Engineering <[email protected]>"]
+name = "rust-outbound-pg-example"
+trigger = { type = "http", base = "/" }
+version = "0.1.0"
+
+[[component]]
+environment = { DB_URL = "host=localhost user=postgres dbname=spin_dev" }
+id = "outbound-pg"
+source = "target/wasm32-wasi/release/http_rust_outbound_pg.wasm"
+[component.trigger]
+route = "/..."
+[component.build]
+command = "cargo build --target wasm32-wasi --release"

tests/outbound-pg/http-rust-outbound-pg/src/lib.rs

@@ -0,0 +1,145 @@
+#![allow(dead_code)]
+use anyhow::{anyhow, Result};
+use spin_sdk::{
+    http::{Request, Response},
+    http_component, pg,
+};
+
+// The environment variable set in `spin.toml` that points to the
+// address of the Pg server that the component will write to
+const DB_URL_ENV: &str = "DB_URL";
+
+#[derive(Debug, Clone)]
+struct Row {
+    id: i32,
+    rvarchar: String,
+    rtext: String,
+}
+
+#[http_component]
+fn process(req: Request) -> Result<Response> {
+    match req.uri().path() {
+        "/test_read_types" => test_read_types(req),
+        "/pg_backend_pid" => pg_backend_pid(req),
+        _ => Ok(http::Response::builder()
+            .status(404)
+            .body(Some("Not found".into()))?),
+    }
+}
+
+fn test_read_types(_req: Request) -> Result<Response> {
+    let address = std::env::var(DB_URL_ENV)?;
+
+    let create_table_sql = r#"
+        CREATE TEMPORARY TABLE test_read_types (
+            id integer GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
+            rvarchar varchar(40) NOT NULL,
+            rtext text NOT NULL
+         );
+    "#;
+
+    pg::execute(&address, create_table_sql, &[])
+        .map_err(|e| anyhow!("Error executing Postgres command: {:?}", e))?;
+
+    let insert_sql = r#"
+        INSERT INTO test_read_types (rvarchar, rtext) VALUES
+        (
+            'rvarchar',
+            'rtext'
+        );
+    "#;
+
+    pg::execute(&address, insert_sql, &[])
+        .map_err(|e| anyhow!("Error executing Postgres command: {:?}", e))?;
+
+    let sql = "SELECT id, rvarchar, rtext FROM test_read_types";
+
+    let rowset = pg::query(&address, sql, &[])
+        .map_err(|e| anyhow!("Error executing Postgres command: {:?}", e))?;
+
+    let column_summary = rowset
+        .columns
+        .iter()
+        .map(format_col)
+        .collect::<Vec<_>>()
+        .join(", ");
+
+    let mut response_lines = vec![];
+
+    for row in rowset.rows {
+        let id = as_int(&row[0])?;
+        let rvarchar = as_owned_string(&row[1])?;
+        let rtext = as_owned_string(&row[2])?;
+
+        let row = Row {
+            id,
+            rvarchar,
+            rtext,
+        };
+
+        response_lines.push(format!("row: {:#?}", row));
+    }
+
+    let response = format!(
+        "Found {} rows(s) as follows:\n{}\n\n(Column info: {})\n",
+        response_lines.len(),
+        response_lines.join("\n"),
+        column_summary,
+    );
+
+    Ok(http::Response::builder()
+        .status(200)
+        .body(Some(response.into()))?)
+}
+
+fn pg_backend_pid(_req: Request) -> Result<Response> {
+    let address = std::env::var(DB_URL_ENV)?;
+    let sql = "SELECT pg_backend_pid()";
+
+    let get_pid = || {
+        let rowset = pg::query(&address, sql, &[])
+            .map_err(|e| anyhow!("Error executing Postgres query: {:?}", e))?;
+
+        let row = &rowset.rows[0];
+        as_int(&row[0])
+    };
+
+    assert_eq!(get_pid()?, get_pid()?);
+
+    let response = format!("pg_backend_pid: {}\n", get_pid()?);
+
+    Ok(http::Response::builder()
+        .status(200)
+        .body(Some(response.into()))?)
+}
+
+fn as_owned_string(value: &pg::DbValue) -> anyhow::Result<String> {
+    match value {
+        pg::DbValue::Str(s) => Ok(s.to_owned()),
+        _ => Err(anyhow!("Expected string from database but got {:?}", value)),
+    }
+}
+
+fn as_int(value: &pg::DbValue) -> anyhow::Result<i32> {
+    match value {
+        pg::DbValue::Int32(n) => Ok(*n),
+        _ => Err(anyhow!(
+            "Expected integer from database but got {:?}",
+            value
+        )),
+    }
+}
+
+fn as_bigint(value: &pg::DbValue) -> anyhow::Result<i64> {
+    match value {
+        pg::DbValue::Int64(n) => Ok(*n),
+        _ => Err(anyhow!(
+            "Expected integer from database but got {:?}",
+            value
+        )),
+    }
+}
+
+fn format_col(column: &pg::Column) -> String {
+    format!("{}:{:?}", column.name, column.data_type)
+}