657 lines
26 KiB
Rust
657 lines
26 KiB
Rust
// tests/table_script/post_scripts_integration_tests.rs
|
|
|
|
use crate::common::setup_isolated_db;
|
|
use server::table_script::handlers::post_table_script::post_table_script;
|
|
use common::proto::komp_ac::table_script::{PostTableScriptRequest, TableScriptResponse};
|
|
use serde_json::json;
|
|
use sqlx::PgPool;
|
|
|
|
/// Test utilities for table script integration testing - moved to top level for shared access
|
|
pub struct TableScriptTestHelper {
|
|
pub pool: PgPool,
|
|
pub schema_id: i64,
|
|
}
|
|
|
|
impl TableScriptTestHelper {
|
|
pub async fn new() -> Self {
|
|
let pool = setup_isolated_db().await;
|
|
let schema_id = sqlx::query_scalar!("SELECT id FROM schemas WHERE name = 'default'")
|
|
.fetch_one(&pool)
|
|
.await
|
|
.expect("Failed to get default schema ID");
|
|
|
|
Self {
|
|
pool,
|
|
schema_id,
|
|
}
|
|
}
|
|
|
|
pub async fn create_table_with_types(&self, table_name: &str, column_definitions: Vec<(&str, &str)>) -> i64 {
|
|
let columns: Vec<String> = column_definitions
|
|
.iter()
|
|
.map(|(name, type_def)| format!("\"{}\" {}", name, type_def))
|
|
.collect();
|
|
|
|
let columns_json = json!(columns);
|
|
let indexes_json = json!([]);
|
|
|
|
sqlx::query_scalar!(
|
|
r#"INSERT INTO table_definitions (schema_id, table_name, columns, indexes)
|
|
VALUES ($1, $2, $3, $4) RETURNING id"#,
|
|
self.schema_id,
|
|
table_name,
|
|
columns_json,
|
|
indexes_json
|
|
)
|
|
.fetch_one(&self.pool)
|
|
.await
|
|
.expect("Failed to create test table")
|
|
}
|
|
|
|
pub async fn create_script(&self, table_id: i64, target_column: &str, script: &str) -> Result<TableScriptResponse, tonic::Status> {
|
|
let request = PostTableScriptRequest {
|
|
table_definition_id: table_id,
|
|
target_column: target_column.to_string(),
|
|
script: script.to_string(),
|
|
description: "Test script".to_string(),
|
|
};
|
|
|
|
post_table_script(&self.pool, request).await
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod integration_tests {
|
|
use super::*;
|
|
|
|
#[tokio::test]
|
|
async fn test_comprehensive_type_validation_matrix() {
|
|
let helper = TableScriptTestHelper::new().await;
|
|
|
|
// Create a comprehensive table with all supported and unsupported types
|
|
let table_id = helper.create_table_with_types(
|
|
"comprehensive_table",
|
|
vec![
|
|
// Supported types for math operations
|
|
("integer_col", "INTEGER"),
|
|
("numeric_basic", "NUMERIC(10, 2)"),
|
|
("numeric_high_precision", "NUMERIC(28, 15)"),
|
|
("numeric_currency", "NUMERIC(14, 4)"),
|
|
|
|
// Supported but not for math operations
|
|
("text_col", "TEXT"),
|
|
("boolean_col", "BOOLEAN"),
|
|
|
|
// Prohibited types entirely
|
|
("bigint_col", "BIGINT"),
|
|
("date_col", "DATE"),
|
|
("timestamp_col", "TIMESTAMPTZ"),
|
|
|
|
// Result columns of various types
|
|
("result_integer", "INTEGER"),
|
|
("result_numeric", "NUMERIC(15, 5)"),
|
|
("result_text", "TEXT"),
|
|
]
|
|
).await;
|
|
|
|
// Test matrix: [source_type, operation, expected_result]
|
|
let test_matrix = vec![
|
|
// Valid mathematical operations
|
|
("integer_col", "+", "result_numeric", true),
|
|
("numeric_basic", "*", "result_numeric", true),
|
|
("numeric_high_precision", "/", "result_numeric", true),
|
|
("integer_col", "sqrt", "result_numeric", true),
|
|
|
|
// Invalid mathematical operations - prohibited types in math
|
|
("text_col", "+", "result_numeric", false),
|
|
("boolean_col", "*", "result_numeric", false),
|
|
("bigint_col", "/", "result_numeric", false),
|
|
("date_col", "-", "result_numeric", false),
|
|
("timestamp_col", "+", "result_numeric", false),
|
|
|
|
// Invalid target columns - prohibited types as targets
|
|
("integer_col", "+", "bigint_col", false),
|
|
("numeric_basic", "*", "date_col", false),
|
|
("integer_col", "/", "timestamp_col", false),
|
|
];
|
|
|
|
for (source_col, operation, target_col, should_succeed) in test_matrix {
|
|
let script = match operation {
|
|
"sqrt" => format!(r#"(sqrt (steel_get_column "comprehensive_table" "{}"))"#, source_col),
|
|
_ => format!(
|
|
r#"({} (steel_get_column "comprehensive_table" "{}") "10")"#,
|
|
operation, source_col
|
|
),
|
|
};
|
|
|
|
let result = helper.create_script(table_id, target_col, &script).await;
|
|
|
|
if should_succeed {
|
|
assert!(
|
|
result.is_ok(),
|
|
"Should succeed: {} {} -> {}",
|
|
source_col, operation, target_col
|
|
);
|
|
} else {
|
|
assert!(
|
|
result.is_err(),
|
|
"Should fail: {} {} -> {}",
|
|
source_col, operation, target_col
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_steel_decimal_precision_requirements() {
|
|
let helper = TableScriptTestHelper::new().await;
|
|
|
|
// Create table with various precision requirements
|
|
let table_id = helper.create_table_with_types(
|
|
"precision_table",
|
|
vec![
|
|
("low_precision", "NUMERIC(5, 2)"), // e.g., 999.99
|
|
("medium_precision", "NUMERIC(10, 4)"), // e.g., 999999.9999
|
|
("high_precision", "NUMERIC(28, 15)"), // Maximum PostgreSQL precision
|
|
("currency", "NUMERIC(14, 4)"), // Standard currency precision
|
|
("percentage", "NUMERIC(5, 4)"), // e.g., 0.9999 (99.99%)
|
|
("integer_val", "INTEGER"),
|
|
("result", "NUMERIC(30, 15)"),
|
|
]
|
|
).await;
|
|
|
|
// Test that steel_decimal can handle various precision levels
|
|
let precision_tests = vec![
|
|
(
|
|
r#"(+ (steel_get_column "precision_table" "low_precision") "0.01")"#,
|
|
"Low precision addition"
|
|
),
|
|
(
|
|
r#"(* (steel_get_column "precision_table" "currency") "1.0001")"#,
|
|
"Currency calculation with high precision multiplier"
|
|
),
|
|
(
|
|
r#"(/ (steel_get_column "precision_table" "high_precision") "3")"#,
|
|
"High precision division"
|
|
),
|
|
(
|
|
r#"(pow (steel_get_column "precision_table" "percentage") "2")"#,
|
|
"Percentage squared"
|
|
),
|
|
(
|
|
r#"(sqrt (steel_get_column "precision_table" "medium_precision"))"#,
|
|
"Square root of medium precision number"
|
|
),
|
|
];
|
|
|
|
for (script, description) in precision_tests {
|
|
let result = helper.create_script(table_id, "result", script).await;
|
|
assert!(
|
|
result.is_ok(),
|
|
"Precision test should succeed: {}",
|
|
description
|
|
);
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_complex_financial_calculations() {
|
|
let helper = TableScriptTestHelper::new().await;
|
|
|
|
// Create a realistic financial table
|
|
let table_id = helper.create_table_with_types(
|
|
"financial_instruments",
|
|
vec![
|
|
("principal", "NUMERIC(16, 2)"), // Principal amount
|
|
("annual_rate", "NUMERIC(6, 5)"), // Interest rate (e.g., 0.05250)
|
|
("years", "INTEGER"), // Time period
|
|
("compounding_periods", "INTEGER"), // Compounding frequency
|
|
("fees", "NUMERIC(10, 2)"), // Transaction fees
|
|
("compound_interest", "NUMERIC(20, 8)"), // Result column
|
|
]
|
|
).await;
|
|
|
|
// Complex compound interest calculation
|
|
let compound_interest_script = r#"
|
|
(-
|
|
(*
|
|
(steel_get_column "financial_instruments" "principal")
|
|
(pow
|
|
(+ "1"
|
|
(/ (steel_get_column "financial_instruments" "annual_rate")
|
|
(steel_get_column "financial_instruments" "compounding_periods")))
|
|
(* (steel_get_column "financial_instruments" "years")
|
|
(steel_get_column "financial_instruments" "compounding_periods"))))
|
|
(+ (steel_get_column "financial_instruments" "principal")
|
|
(steel_get_column "financial_instruments" "fees")))
|
|
"#;
|
|
|
|
let result = helper.create_script(table_id, "compound_interest", compound_interest_script).await;
|
|
assert!(result.is_ok(), "Complex financial calculation should succeed");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_scientific_notation_support() {
|
|
let helper = TableScriptTestHelper::new().await;
|
|
|
|
let table_id = helper.create_table_with_types(
|
|
"scientific_data",
|
|
vec![
|
|
("large_number", "NUMERIC(30, 10)"),
|
|
("small_number", "NUMERIC(30, 20)"),
|
|
("result", "NUMERIC(35, 25)"),
|
|
]
|
|
).await;
|
|
|
|
// Test that steel_decimal can handle scientific notation in scripts
|
|
let scientific_script = r#"
|
|
(+
|
|
(steel_get_column "scientific_data" "large_number")
|
|
(* "1.5e-10" (steel_get_column "scientific_data" "small_number")))
|
|
"#;
|
|
|
|
let result = helper.create_script(table_id, "result", scientific_script).await;
|
|
assert!(result.is_ok(), "Scientific notation should be supported");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_script_dependencies_and_cycles() {
|
|
let helper = TableScriptTestHelper::new().await;
|
|
|
|
println!("=== DEPENDENCY TEST DEBUG START ===");
|
|
println!("Schema ID: {}", helper.schema_id);
|
|
|
|
// Create multiple tables to test dependencies
|
|
let table_a_id = helper.create_table_with_types(
|
|
"table_a",
|
|
vec![
|
|
("value_a", "NUMERIC(10, 2)"),
|
|
("result_a", "NUMERIC(10, 2)"),
|
|
]
|
|
).await;
|
|
println!("Created table_a with ID: {}", table_a_id);
|
|
|
|
let table_b_id = helper.create_table_with_types(
|
|
"table_b",
|
|
vec![
|
|
("value_b", "NUMERIC(10, 2)"),
|
|
("result_b", "NUMERIC(10, 2)"),
|
|
]
|
|
).await;
|
|
println!("Created table_b with ID: {}", table_b_id);
|
|
|
|
// Check what tables exist in the database
|
|
let existing_tables = sqlx::query!(
|
|
"SELECT table_name FROM table_definitions WHERE schema_id = $1",
|
|
helper.schema_id
|
|
)
|
|
.fetch_all(&helper.pool)
|
|
.await
|
|
.expect("Failed to fetch existing tables");
|
|
|
|
println!("Existing tables in schema {}: {:?}",
|
|
helper.schema_id,
|
|
existing_tables.iter().map(|t| &t.table_name).collect::<Vec<_>>()
|
|
);
|
|
|
|
// Create first script: table_a.result_a depends on table_b.value_b
|
|
let script_a = r#"(+ (steel_get_column "table_b" "value_b") "10")"#;
|
|
println!("Testing cross-table script: {}", script_a);
|
|
|
|
let result_a: Result<TableScriptResponse, tonic::Status> = helper.create_script(table_a_id, "result_a", script_a).await;
|
|
|
|
match &result_a {
|
|
Ok(response) => {
|
|
println!("✓ Cross-table dependency succeeded! Script ID: {}", response.id);
|
|
},
|
|
Err(error) => {
|
|
println!("✗ Cross-table dependency failed!");
|
|
println!("Error code: {:?}", error.code());
|
|
println!("Error message: {}", error.message());
|
|
println!("Full error: {:?}", error);
|
|
|
|
// Check if this is expected (cross-table not supported) or unexpected bug
|
|
let error_str = error.to_string();
|
|
if error_str.contains("does not exist") || error_str.contains("not found") {
|
|
println!("This appears to be a cross-table reference limitation - skipping cycle test");
|
|
println!("=== DEPENDENCY TEST DEBUG END (SKIPPED) ===");
|
|
return; // Skip the rest if cross-table isn't supported
|
|
}
|
|
}
|
|
}
|
|
|
|
assert!(result_a.is_ok(), "First dependency script should succeed, got error: {:?}", result_a.err());
|
|
|
|
// Try to create circular dependency: table_b.result_b depends on table_a.result_a
|
|
let script_b = r#"(* (steel_get_column "table_a" "result_a") "2")"#;
|
|
println!("Testing circular dependency script: {}", script_b);
|
|
|
|
let result_b: Result<TableScriptResponse, tonic::Status> = helper.create_script(table_b_id, "result_b", script_b).await;
|
|
|
|
match &result_b {
|
|
Ok(response) => {
|
|
println!("⚠ Circular dependency was allowed! Script ID: {}", response.id);
|
|
println!("This might indicate cycle detection is not implemented or is lenient");
|
|
},
|
|
Err(error) => {
|
|
println!("✓ Circular dependency was blocked: {}", error.message());
|
|
let error_str = error.to_string();
|
|
assert!(
|
|
error_str.contains("cycle") || error_str.contains("circular"),
|
|
"Circular dependency should be detected with 'cycle' or 'circular' in message, got: {}",
|
|
error_str
|
|
);
|
|
}
|
|
}
|
|
|
|
println!("=== DEPENDENCY TEST DEBUG END ===");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_error_message_quality() {
|
|
let helper = TableScriptTestHelper::new().await;
|
|
|
|
let table_id = helper.create_table_with_types(
|
|
"error_test_table",
|
|
vec![
|
|
("text_field", "TEXT"),
|
|
("numeric_field", "NUMERIC(10, 2)"),
|
|
("boolean_field", "BOOLEAN"),
|
|
("bigint_field", "BIGINT"),
|
|
]
|
|
).await;
|
|
|
|
// Test various error scenarios and check error message quality
|
|
let error_scenarios = vec![
|
|
(
|
|
"bigint_field",
|
|
"(+ \"10\" \"20\")",
|
|
vec!["cannot create script", "BIGINT", "cannot target columns of type"],
|
|
"Targeting prohibited type should give clear error"
|
|
),
|
|
(
|
|
"numeric_field",
|
|
r#"(+ (steel_get_column "error_test_table" "text_field") "10")"#,
|
|
vec!["mathematical", "TEXT", "operations"],
|
|
"TEXT in math operations should give clear error"
|
|
),
|
|
(
|
|
"numeric_field",
|
|
r#"(* (steel_get_column "error_test_table" "boolean_field") "5")"#,
|
|
vec!["mathematical", "BOOLEAN", "operations"],
|
|
"BOOLEAN in math operations should give clear error"
|
|
),
|
|
(
|
|
"numeric_field",
|
|
r#"(+ (steel_get_column "nonexistent_table" "field") "10")"#,
|
|
vec!["table", "does not exist", "nonexistent_table"],
|
|
"Nonexistent table should give clear error"
|
|
),
|
|
(
|
|
"numeric_field",
|
|
r#"(+ (steel_get_column "error_test_table" "nonexistent_field") "10")"#,
|
|
vec!["column", "does not exist", "nonexistent_field"],
|
|
"Nonexistent column should give clear error"
|
|
),
|
|
];
|
|
|
|
for (target_column, script, expected_keywords, description) in error_scenarios {
|
|
let result = helper.create_script(table_id, target_column, script).await;
|
|
assert!(result.is_err(), "{}", description);
|
|
|
|
let error_message = result.unwrap_err().to_string().to_lowercase();
|
|
for keyword in expected_keywords {
|
|
assert!(
|
|
error_message.contains(&keyword.to_lowercase()),
|
|
"Error message should contain '{}' for: {}. Got: {}",
|
|
keyword, description, error_message
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_performance_with_complex_nested_expressions() {
|
|
let helper = TableScriptTestHelper::new().await;
|
|
|
|
let table_id = helper.create_table_with_types(
|
|
"performance_table",
|
|
vec![
|
|
("x", "NUMERIC(15, 8)"),
|
|
("y", "NUMERIC(15, 8)"),
|
|
("z", "NUMERIC(15, 8)"),
|
|
("w", "NUMERIC(15, 8)"),
|
|
("complex_result", "NUMERIC(25, 12)"),
|
|
]
|
|
).await;
|
|
|
|
// Create a deeply nested mathematical expression
|
|
let complex_script = r#"
|
|
(+
|
|
(*
|
|
(pow (steel_get_column "performance_table" "x") "3")
|
|
(sqrt (steel_get_column "performance_table" "y")))
|
|
(-
|
|
(/
|
|
(+ (steel_get_column "performance_table" "z") "100")
|
|
(max (steel_get_column "performance_table" "w") "1"))
|
|
(* "0.5"
|
|
(abs (- (steel_get_column "performance_table" "x")
|
|
(steel_get_column "performance_table" "y"))))))
|
|
"#;
|
|
|
|
let start_time = std::time::Instant::now();
|
|
let result = helper.create_script(table_id, "complex_result", complex_script).await;
|
|
let duration = start_time.elapsed();
|
|
|
|
assert!(result.is_ok(), "Complex nested expression should succeed");
|
|
assert!(duration.as_millis() < 1000, "Script validation should complete within 1 second");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_boundary_conditions() {
|
|
let helper = TableScriptTestHelper::new().await;
|
|
|
|
// Test boundary conditions for NUMERIC types
|
|
let table_id = helper.create_table_with_types(
|
|
"boundary_table",
|
|
vec![
|
|
("min_numeric", "NUMERIC(1, 0)"), // Minimum: single digit, no decimal
|
|
("max_numeric", "NUMERIC(1000, 999)"), // Maximum PostgreSQL allows
|
|
("zero_scale", "NUMERIC(10, 0)"), // Integer-like numeric
|
|
("max_scale", "NUMERIC(28, 28)"), // Maximum scale
|
|
("result", "NUMERIC(1000, 999)"),
|
|
]
|
|
).await;
|
|
|
|
let boundary_script = r#"
|
|
(+
|
|
(steel_get_column "boundary_table" "min_numeric")
|
|
(steel_get_column "boundary_table" "zero_scale"))
|
|
"#;
|
|
|
|
let result = helper.create_script(table_id, "result", boundary_script).await;
|
|
assert!(result.is_ok(), "Boundary condition numeric types should be supported");
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod steel_decimal_integration_tests {
|
|
use super::*;
|
|
use server::steel::server::execution::execute_script;
|
|
use std::sync::Arc;
|
|
use std::collections::HashMap;
|
|
|
|
#[tokio::test]
|
|
async fn test_steel_decimal_execution_with_valid_types() {
|
|
println!("=== STEEL DECIMAL EXECUTION DEBUG START ===");
|
|
|
|
let helper = TableScriptTestHelper::new().await;
|
|
let pool = Arc::new(helper.pool.clone());
|
|
|
|
println!("Schema ID: {}", helper.schema_id);
|
|
|
|
// Create a proper table for the test
|
|
let table_id = helper.create_table_with_types(
|
|
"test_execution_table",
|
|
vec![
|
|
("amount", "NUMERIC(10, 2)"),
|
|
("quantity", "INTEGER"),
|
|
("tax_rate", "NUMERIC(5, 4)"),
|
|
("result", "NUMERIC(15, 4)"), // Add a result column
|
|
]
|
|
).await;
|
|
println!("Created test table with ID: {}", table_id);
|
|
|
|
// Test row data
|
|
let mut row_data = HashMap::new();
|
|
row_data.insert("amount".to_string(), "100.50".to_string());
|
|
row_data.insert("quantity".to_string(), "5".to_string());
|
|
row_data.insert("tax_rate".to_string(), "0.0825".to_string());
|
|
|
|
// Script with proper $-prefixed variables (steel_decimal syntax)
|
|
let script = r#"
|
|
(+
|
|
(* $amount $quantity)
|
|
(* $amount $tax_rate))
|
|
"#;
|
|
|
|
println!("Script with $-prefixed variables: {}", script);
|
|
|
|
// STEP 1: Create the script via post_table_script (this transforms it)
|
|
let script_creation_result = helper.create_script(table_id, "result", script).await;
|
|
assert!(script_creation_result.is_ok(), "Script creation should succeed");
|
|
let script_response = script_creation_result.unwrap();
|
|
println!("✓ Script created with ID: {}", script_response.id);
|
|
|
|
// STEP 2: Load the transformed script from the database
|
|
let script_record = sqlx::query!(
|
|
"SELECT script FROM table_scripts WHERE id = $1",
|
|
script_response.id
|
|
)
|
|
.fetch_one(&helper.pool)
|
|
.await
|
|
.expect("Should be able to load the created script");
|
|
|
|
let transformed_script = script_record.script;
|
|
println!("Transformed script: {}", transformed_script);
|
|
|
|
// STEP 3: Execute the transformed script
|
|
let result = execute_script(
|
|
transformed_script, // ✅ Now using the transformed script
|
|
"STRINGS",
|
|
pool.clone(),
|
|
helper.schema_id,
|
|
"default".to_string(),
|
|
"test_execution_table".to_string(),
|
|
row_data.clone(),
|
|
).await;
|
|
|
|
match &result {
|
|
Ok(value) => {
|
|
println!("✓ Steel decimal execution succeeded!");
|
|
println!("Result: {:?}", value);
|
|
},
|
|
Err(error) => {
|
|
println!("✗ Steel decimal execution failed!");
|
|
println!("Error: {}", error);
|
|
}
|
|
}
|
|
|
|
println!("=== STEEL DECIMAL EXECUTION DEBUG END ===");
|
|
assert!(result.is_ok(), "Steel decimal execution should succeed with valid numeric types, got: {:?}", result.err());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_steel_decimal_precision_handling() {
|
|
println!("=== STEEL DECIMAL PRECISION DEBUG START ===");
|
|
|
|
let helper = TableScriptTestHelper::new().await;
|
|
let pool = Arc::new(helper.pool.clone());
|
|
|
|
println!("Schema ID: {}", helper.schema_id);
|
|
|
|
// Create a table with high precision columns
|
|
let table_id = helper.create_table_with_types(
|
|
"precision_test_table",
|
|
vec![
|
|
("precise_value", "NUMERIC(20, 12)"),
|
|
("multiplier", "NUMERIC(20, 12)"),
|
|
("result", "NUMERIC(25, 15)"), // Add result column
|
|
]
|
|
).await;
|
|
println!("Created precision test table with ID: {}", table_id);
|
|
|
|
// Test high precision calculations
|
|
let mut row_data = HashMap::new();
|
|
row_data.insert("precise_value".to_string(), "123.456789012345".to_string());
|
|
row_data.insert("multiplier".to_string(), "2.718281828459045".to_string());
|
|
|
|
// Script with proper $-prefixed variables
|
|
let script = r#"(* $precise_value $multiplier)"#;
|
|
|
|
println!("Precision script with $-prefixed variables: {}", script);
|
|
|
|
// STEP 1: Create the script via post_table_script (this transforms it)
|
|
let script_creation_result = helper.create_script(table_id, "result", script).await;
|
|
assert!(script_creation_result.is_ok(), "Script creation should succeed");
|
|
let script_response = script_creation_result.unwrap();
|
|
println!("✓ Precision script created with ID: {}", script_response.id);
|
|
|
|
// STEP 2: Load the transformed script from the database
|
|
let script_record = sqlx::query!(
|
|
"SELECT script FROM table_scripts WHERE id = $1",
|
|
script_response.id
|
|
)
|
|
.fetch_one(&helper.pool)
|
|
.await
|
|
.expect("Should be able to load the created script");
|
|
|
|
let transformed_script = script_record.script;
|
|
println!("Transformed precision script: {}", transformed_script);
|
|
|
|
// STEP 3: Execute the transformed script
|
|
let result = execute_script(
|
|
transformed_script, // ✅ Now using the transformed script
|
|
"STRINGS",
|
|
pool.clone(),
|
|
helper.schema_id,
|
|
"default".to_string(),
|
|
"precision_test_table".to_string(),
|
|
row_data,
|
|
).await;
|
|
|
|
match &result {
|
|
Ok(value) => {
|
|
println!("✓ Steel decimal precision test succeeded!");
|
|
match value {
|
|
server::steel::server::execution::Value::Strings(values) => {
|
|
println!("String results: {:?}", values);
|
|
if !values.is_empty() {
|
|
if let Ok(result_value) = values[0].parse::<f64>() {
|
|
println!("Parsed result: {}", result_value);
|
|
println!("Expected > 300.0: {}", result_value > 300.0);
|
|
}
|
|
}
|
|
},
|
|
other => println!("Non-string result: {:?}", other),
|
|
}
|
|
},
|
|
Err(error) => {
|
|
println!("✗ Steel decimal precision test failed!");
|
|
println!("Error: {}", error);
|
|
}
|
|
}
|
|
|
|
println!("=== STEEL DECIMAL PRECISION DEBUG END ===");
|
|
assert!(result.is_ok(), "Steel decimal should handle high precision calculations, got: {:?}", result.err());
|
|
|
|
if let Ok(server::steel::server::execution::Value::Strings(values)) = result {
|
|
assert!(!values.is_empty(), "Should return calculated values");
|
|
// The result should maintain precision
|
|
let result_value: f64 = values[0].parse().unwrap_or(0.0);
|
|
assert!(result_value > 300.0, "Calculation result should be reasonable, got: {}", result_value);
|
|
}
|
|
}
|
|
}
|