tlsnotary/tlsn-js
1
0
Fork 0
mirror of https://github.com/tlsnotary/tlsn-js.git synced 2026-01-08 20:18:01 -05:00
Code Issues Packages Projects Releases 10 Wiki Activity

Cleaned up tests

Browse Source
This commit is contained in:
Hendrik Eeckhaut
2025-09-23 11:33:58 +02:00
parent be3ee16bb7
commit 62dc1e3c74
3 changed files with 81 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
demo/interactive/tlsn-demo-server/src/prover.rs
View File

@@ -9,31 +9,12 @@ use spansy::{
};
use crate::config::{MAX_RECV_DATA, MAX_SENT_DATA, SECRET};
use crate::websocket_utils::create_websocket_request;
use async_tungstenite::{tokio::connect_async_with_config, tungstenite::protocol::WebSocketConfig};
use tlsn::{
config::ProtocolConfig,
connection::ServerName,
prover::{ProveConfig, ProveConfigBuilder, Prover, ProverConfig},
};
use tlsn::config::ProtocolConfig;
use tlsn::connection::ServerName;
use tlsn::prover::{ProveConfig, ProveConfigBuilder, Prover, ProverConfig};
use tokio::io::{AsyncRead, AsyncWrite};
use tokio_util::compat::{FuturesAsyncReadCompatExt, TokioAsyncReadCompatExt};
use tracing::{debug, info};
use ws_stream_tungstenite::WsStream;
/// Make sure the following url's domain is the same as SERVER_DOMAIN on the verifier side
pub async fn run_prover_test(config: &crate::config::Config) -> Result<(), eyre::ErrReport> {
info!("Sending websocket verify request to server...");
let request = create_websocket_request(&config.host, config.port, "/verify");
let (ws_stream, _) = connect_async_with_config(request, Some(WebSocketConfig::default()))
.await
.map_err(|e| eyre::eyre!("Failed to connect to server: {}", e))?;
let server_ws_socket = WsStream::new(ws_stream);
info!("Websocket connection established with prover!");
prover(server_ws_socket, &config.server_url).await?;
info!("Proving is successful!");
Ok(())
}
pub async fn prover<T: AsyncWrite + AsyncRead + Send + Unpin + 'static>(
verifier_socket: T,
@@ -161,4 +142,4 @@ fn redact_and_reveal_sent_data(sent_transcript: &[u8]) -> RangeSet<usize> {
secret_start + SECRET.len()..sent_transcript_len,
]
.into()
}
}

19
demo/interactive/tlsn-demo-server/src/verifier.rs
View File

@@ -1,6 +1,4 @@
use crate::config::{Config, MAX_RECV_DATA, MAX_SENT_DATA};
use crate::websocket_utils::create_websocket_request;
use async_tungstenite::{tokio::connect_async_with_config, tungstenite::protocol::WebSocketConfig};
use crate::config::{MAX_RECV_DATA, MAX_SENT_DATA};
use eyre::eyre;
use tlsn::{
config::ProtocolConfigValidator,
@@ -10,21 +8,6 @@ use tlsn::{
use tokio::io::{AsyncRead, AsyncWrite};
use tokio_util::compat::TokioAsyncReadCompatExt;
use tracing::{debug, info};
use ws_stream_tungstenite::WsStream;
/// Connect to prover via websocket and run verification
pub async fn run_verifier_test(config: &Config) -> Result<(), eyre::ErrReport> {
info!("Sending websocket request to prover...");
let request = create_websocket_request(&config.host, config.port, "/prove");
let (ws_stream, _) = connect_async_with_config(request, Some(WebSocketConfig::default()))
.await
.map_err(|e| eyre!("Failed to connect to prover: {}", e))?;
let prover_ws_socket = WsStream::new(ws_stream);
info!("Websocket connection established with prover!");
verifier(prover_ws_socket, &config.server_domain()).await?;
info!("Verification is successful!");
Ok(())
}
/// Core verifier logic that validates the TLS proof
pub async fn verifier<T: AsyncWrite + AsyncRead + Send + Unpin + 'static>(

140
demo/interactive/tlsn-demo-server/tests/integration_test.rs
View File

@@ -1,111 +1,123 @@
use std::time::Duration;
use tlsn_demo_server::{
config::Config, prover::run_prover_test, run_server, verifier::run_verifier_test,
};
use tlsn_demo_server::{config::Config, prover::prover, run_server, verifier::verifier};
use tokio::time::timeout;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
const TRACING_FILTER: &str = "INFO";
use async_tungstenite::{tokio::connect_async_with_config, tungstenite::protocol::WebSocketConfig};
use eyre::eyre;
use tlsn_demo_server::websocket_utils::create_websocket_request;
use tracing::info;
use ws_stream_tungstenite::WsStream;
#[tokio::test]
async fn test_prover_verifier_integration() {
// Initialize tracing for test output
const TRACING_FILTER: &str = "INFO";
const SERVER_START_DELAY: Duration = Duration::from_millis(500);
const TEST_TIMEOUT: Duration = Duration::from_secs(60);
fn init_tracing() {
let _ = tracing_subscriber::registry()
.with(EnvFilter::try_from_default_env().unwrap_or_else(|_| TRACING_FILTER.into()))
.with(tracing_subscriber::fmt::layer())
.try_init();
}
// Start prover server in background task
let server_task = tokio::spawn(async move {
let config: Config = Config::default();
async fn start_test_server() -> tokio::task::JoinHandle<()> {
tokio::spawn(async move {
let config = Config::default();
run_server(&config)
.await
.expect("Server should start successfully")
});
})
}
// Wait for server to start up
tokio::time::sleep(Duration::from_millis(500)).await;
#[tokio::test]
async fn test_prover_verifier_integration() {
init_tracing();
// Run verifier test with timeout
let config: Config = Config::default();
let verification_result = timeout(
Duration::from_secs(60), // Generous timeout for network operations
run_verifier_test(&config),
)
let server_task = start_test_server().await;
tokio::time::sleep(SERVER_START_DELAY).await;
let config = Config::default();
let result = timeout(TEST_TIMEOUT, async {
info!("Connecting to server as verifier...");
let request = create_websocket_request(&config.host, config.port, "/prove");
let (ws_stream, _) = connect_async_with_config(request, Some(WebSocketConfig::default()))
.await
.map_err(|e| eyre!("Failed to connect to server: {}", e))?;
let server_ws_socket = WsStream::new(ws_stream);
info!("WebSocket connection established with server!");
verifier(server_ws_socket, &config.server_domain()).await?;
info!("Verification completed successfully!");
Ok::<(), eyre::ErrReport>(())
})
.await;
// Clean up server task
server_task.abort();
// Assert verification succeeded
match verification_result {
match result {
Ok(Ok(())) => {
println!("✅ Integration test passed: Prover-Verifier communication successful");
}
Ok(Err(e)) => {
panic!("❌ Verification failed: {}", e);
}
Err(_) => {
panic!("❌ Verification timed out after 60 seconds");
println!("✅ Integration test passed: Prover-Verifier communication successful")
}
Ok(Err(e)) => panic!("❌ Test failed: {}", e),
Err(_) => panic!("❌ Test timed out after {:?}", TEST_TIMEOUT),
}
}
#[tokio::test]
async fn test_verifier_prover_integration() {
// Initialize tracing for test output
let _ = tracing_subscriber::registry()
.with(EnvFilter::try_from_default_env().unwrap_or_else(|_| TRACING_FILTER.into()))
.with(tracing_subscriber::fmt::layer())
.try_init();
init_tracing();
// Start prover server in background task
let server_task = tokio::spawn(async move {
let config: Config = Config::default();
run_server(&config)
let server_task = start_test_server().await;
tokio::time::sleep(SERVER_START_DELAY).await;
let config = Config::default();
let result = timeout(TEST_TIMEOUT, async {
info!("Connecting to server as prover...");
let request = create_websocket_request(&config.host, config.port, "/verify");
let (ws_stream, _) = connect_async_with_config(request, Some(WebSocketConfig::default()))
.await
.expect("Server should start successfully")
});
// Wait for server to start up
tokio::time::sleep(Duration::from_millis(500)).await;
// Run verifier test with timeout
let config: Config = Config::default();
let prover_result = timeout(
Duration::from_secs(60), // Generous timeout for network operations
run_prover_test(&config),
)
.map_err(|e| eyre!("Failed to connect to server: {}", e))?;
let server_ws_socket = WsStream::new(ws_stream);
info!("WebSocket connection established with server!");
prover(server_ws_socket, &config.server_url).await?;
info!("Proving completed successfully!");
Ok::<(), eyre::ErrReport>(())
})
.await;
// Clean up server task
server_task.abort();
// Assert verification succeeded
match prover_result {
match result {
Ok(Ok(())) => {
println!("✅ Integration test passed: Prover-Verifier communication successful");
}
Ok(Err(e)) => {
panic!("❌ Verification failed: {}", e);
}
Err(_) => {
panic!("❌ Verification timed out after 60 seconds");
println!("✅ Integration test passed: Verifier-Prover communication successful")
}
Ok(Err(e)) => panic!("❌ Test failed: {}", e),
Err(_) => panic!("❌ Test timed out after {:?}", TEST_TIMEOUT),
}
}
#[tokio::test]
async fn test_verifier_connection_failure() {
// Test that verifier handles connection failure gracefully
init_tracing();
let config = Config {
port: 54321, // wrong port
port: 54321, // Non-existent port
..Config::default()
};
let result = timeout(Duration::from_secs(5), run_verifier_test(&config)).await;
let result = timeout(Duration::from_secs(5), async {
info!("Connecting to server as verifier...");
let request = create_websocket_request(&config.host, config.port, "/prove");
let (ws_stream, _) = connect_async_with_config(request, Some(WebSocketConfig::default()))
.await
.map_err(|e| eyre!("Failed to connect to server: {}", e))?;
let server_ws_socket = WsStream::new(ws_stream);
info!("WebSocket connection established with server!");
verifier(server_ws_socket, &config.server_domain()).await?;
info!("Verification completed successfully!");
Ok::<(), eyre::ErrReport>(())
})
.await;
// Should either timeout or return an error
match result {
Ok(Ok(())) => panic!("Should not succeed when connecting to non-existent server"),
Ok(Err(_)) => println!("✅ Correctly failed to connect to non-existent server"),