filipriec/komp_ac
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

needs last one to be fixed, otherwise its getting perfect

Browse Source
This commit is contained in:
filipriec
2025-06-21 23:57:52 +02:00
parent 87b9f6ab87
commit 92d5eb4844
5 changed files with 323 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
server/src/table_definition/handlers/post_table_definition.rs
View File

@@ -16,23 +16,41 @@ const PREDEFINED_FIELD_TYPES: &[(&str, &str)] = &[
("date", "DATE"),
];
fn is_valid_identifier(s: &str) -> bool {
!s.is_empty() &&
s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') &&
!s.starts_with('_') &&
!s.chars().next().unwrap().is_ascii_digit()
// NEW: Helper function to provide detailed error messages
fn validate_identifier_format(s: &str, identifier_type: &str) -> Result<(), Status> {
if s.is_empty() {
return Err(Status::invalid_argument(format!("{} cannot be empty", identifier_type)));
}
fn sanitize_table_name(s: &str) -> String {
s.replace(|c: char| !c.is_ascii_alphanumeric() && c != '_', "")
.trim()
.to_lowercase()
if s.starts_with('_') {
return Err(Status::invalid_argument(format!("{} cannot start with underscore", identifier_type)));
}
fn sanitize_identifier(s: &str) -> String {
s.replace(|c: char| !c.is_ascii_alphanumeric() && c != '_', "")
.trim()
.to_lowercase()
if s.chars().next().unwrap().is_ascii_digit() {
return Err(Status::invalid_argument(format!("{} cannot start with a number", identifier_type)));
}
// Check for invalid characters
let invalid_chars: Vec<char> = s.chars()
.filter(|c| !c.is_ascii_lowercase() && !c.is_ascii_digit() && *c != '_')
.collect();
if !invalid_chars.is_empty() {
return Err(Status::invalid_argument(format!(
"{} contains invalid characters: {:?}. Only lowercase letters, numbers, and underscores are allowed",
identifier_type, invalid_chars
)));
}
// Check for uppercase letters specifically to give a helpful message
if s.chars().any(|c| c.is_ascii_uppercase()) {
return Err(Status::invalid_argument(format!(
"{} contains uppercase letters. Only lowercase letters are allowed",
identifier_type
)));
}
Ok(())
}
fn map_field_type(field_type: &str) -> Result<String, Status> {
@@ -107,65 +125,56 @@ fn is_reserved_schema(schema_name: &str) -> bool {
pub async fn post_table_definition(
db_pool: &PgPool,
request: PostTableDefinitionRequest,
mut request: PostTableDefinitionRequest, // Changed to mutable
) -> Result<TableDefinitionResponse, Status> {
if request.profile_name.trim().is_empty() {
return Err(Status::invalid_argument("Profile name cannot be empty"));
}
// Apply same sanitization rules as table names
let sanitized_profile_name = sanitize_identifier(&request.profile_name);
// Create owned copies of the strings after validation
let profile_name = {
let trimmed = request.profile_name.trim();
validate_identifier_format(trimmed, "Profile name")?;
trimmed.to_string()
};
// Add validation to prevent reserved schemas
if is_reserved_schema(&sanitized_profile_name) {
if is_reserved_schema(&profile_name) {
return Err(Status::invalid_argument("Profile name is reserved and cannot be used"));
}
if !is_valid_identifier(&sanitized_profile_name) {
return Err(Status::invalid_argument("Invalid profile name"));
}
const MAX_IDENTIFIER_LENGTH: usize = 63;
if sanitized_profile_name.len() > MAX_IDENTIFIER_LENGTH {
if profile_name.len() > MAX_IDENTIFIER_LENGTH {
return Err(Status::invalid_argument(format!(
"Profile name '{}' exceeds the {} character limit.",
sanitized_profile_name,
profile_name,
MAX_IDENTIFIER_LENGTH
)));
}
let base_name = sanitize_table_name(&request.table_name);
if base_name.len() > MAX_IDENTIFIER_LENGTH {
let table_name = {
let trimmed = request.table_name.trim();
validate_identifier_format(trimmed, "Table name")?;
if trimmed.len() > MAX_IDENTIFIER_LENGTH {
return Err(Status::invalid_argument(format!(
"Identifier '{}' exceeds the {} character limit.",
base_name,
"Table name '{}' exceeds the {} character limit.",
trimmed,
MAX_IDENTIFIER_LENGTH
)));
}
let user_part_cleaned = request.table_name
.replace(|c: char| !c.is_ascii_alphanumeric() && c != '_', "")
.trim_matches('_')
.to_lowercase();
// New validation check
if is_invalid_table_name(&user_part_cleaned) {
// Check invalid table names on the original input
if is_invalid_table_name(trimmed) {
return Err(Status::invalid_argument(
"Table name cannot be 'id', 'deleted', 'created_at' or end with '_id'"
));
}
if !user_part_cleaned.is_empty() && !is_valid_identifier(&user_part_cleaned) {
return Err(Status::invalid_argument("Invalid table name"));
} else if user_part_cleaned.is_empty() {
return Err(Status::invalid_argument("Table name cannot be empty"));
}
trimmed.to_string()
};
let mut tx = db_pool.begin().await
.map_err(|e| Status::internal(format!("Failed to start transaction: {}", e)))?;
match execute_table_definition(&mut tx, request, base_name, sanitized_profile_name).await {
match execute_table_definition(&mut tx, request, table_name, profile_name).await {
Ok(response) => {
tx.commit().await
.map_err(|e| Status::internal(format!("Failed to commit transaction: {}", e)))?;
@@ -184,12 +193,12 @@ async fn execute_table_definition(
table_name: String,
profile_name: String,
) -> Result<TableDefinitionResponse, Status> {
// CHANGED: Use schemas table instead of profiles table
// Use the validated profile_name for schema insertion
let schema = sqlx::query!(
"INSERT INTO schemas (name) VALUES ($1)
ON CONFLICT (name) DO UPDATE SET name = EXCLUDED.name
RETURNING id",
request.profile_name
profile_name // Use the validated profile name
)
.fetch_one(&mut **tx)
.await
@@ -233,32 +242,34 @@ async fn execute_table_definition(
let mut columns = Vec::new();
for col_def in request.columns.drain(..) {
let col_name = sanitize_identifier(&col_def.name);
if !is_valid_identifier(&col_def.name) {
return Err(Status::invalid_argument("Invalid column name"));
}
let col_name = col_def.name.trim().to_string();
validate_identifier_format(&col_name, "Column name")?;
if col_name.ends_with("_id") || col_name == "id" || col_name == "deleted" || col_name == "created_at" {
return Err(Status::invalid_argument("Column name cannot be 'id', 'deleted', 'created_at' or end with '_id'"));
return Err(Status::invalid_argument(format!(
"Column name '{}' cannot be 'id', 'deleted', 'created_at' or end with '_id'",
col_name
)));
}
let sql_type = map_field_type(&col_def.field_type)?;
columns.push(format!("\"{}\" {}", col_name, sql_type));
}
let mut indexes = Vec::new();
for idx in request.indexes.drain(..) {
let idx_name = sanitize_identifier(&idx);
if !is_valid_identifier(&idx) {
return Err(Status::invalid_argument(format!("Invalid index name: {}", idx)));
}
let idx_name = idx.trim().to_string();
validate_identifier_format(&idx_name, "Index name")?;
if !columns.iter().any(|c| c.starts_with(&format!("\"{}\"", idx_name))) {
return Err(Status::invalid_argument(format!("Index column {} not found", idx_name)));
return Err(Status::invalid_argument(format!("Index column '{}' not found", idx_name)));
}
indexes.push(idx_name);
}
let (create_sql, index_sql) = generate_table_sql(tx, &profile_name, &table_name, &columns, &indexes, &links).await?;
// CHANGED: Use schema_id instead of profile_id
// Use schema_id instead of profile_id
let table_def = sqlx::query!(
r#"INSERT INTO table_definitions
(schema_id, table_name, columns, indexes)
@@ -273,7 +284,7 @@ async fn execute_table_definition(
.await
.map_err(|e| {
if let Some(db_err) = e.as_database_error() {
// CHANGED: Update constraint name to match new schema
// Update constraint name to match new schema
if db_err.constraint() == Some("idx_table_definitions_schema_table") {
return Status::already_exists("Table already exists in this profile");
}
@@ -321,7 +332,7 @@ async fn generate_table_sql(
indexes: &[String],
links: &[(i64, bool)],
) -> Result<(String, Vec<String>), Status> {
// CHANGE: Quote the schema name
// Quote the schema name
let qualified_table = format!("\"{}\".\"{}\"", profile_name, table_name);
let mut system_columns = vec![
@@ -331,7 +342,7 @@ async fn generate_table_sql(
for (linked_id, required) in links {
let linked_table = get_table_name_by_id(tx, *linked_id).await?;
// CHANGE: Quote the schema name here too
// Quote the schema name here too
let qualified_linked_table = format!("\"{}\".\"{}\"", profile_name, linked_table);
let base_name = linked_table.split_once('_')
.map(|(_, rest)| rest)

96
server/tests/table_definition/post_table_definition_test.rs
View File

@@ -374,13 +374,11 @@ async fn test_fail_on_index_for_nonexistent_column(#[future] pool: PgPool) {
..Default::default()
};
// Act
let result = post_table_definition(&pool, request).await;
// Assert
let err = result.unwrap_err();
assert_eq!(err.code(), Code::InvalidArgument);
assert!(err.message().contains("Index column fake_column not found"));
assert!(result.is_err());
if let Err(err) = result {
assert!(err.message().contains("Index column 'fake_column' not found"));
}
}
#[rstest]
@@ -512,20 +510,88 @@ async fn test_fail_on_column_name_suffix_id(#[future] pool: PgPool) {
let pool = pool.await;
let request = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "tbl_suffix_id".into(),
table_name: "valid_table".into(), // FIXED: Use valid table name
columns: vec![ColumnDefinition {
name: "user_id".into(),
name: "invalid_column_id".into(), // FIXED: Test invalid COLUMN name
field_type: "text".into(),
}],
..Default::default()
};
let err = post_table_definition(&pool, request).await.unwrap_err();
assert_eq!(err.code(), Code::InvalidArgument);
assert!(
err.message().to_lowercase().contains("invalid column name"),
"unexpected error message: {}",
err.message()
);
let result = post_table_definition(&pool, request).await;
assert!(result.is_err());
if let Err(status) = result {
// UPDATED: Should mention column, not table
assert!(status.message().contains("Column name") &&
status.message().contains("end with '_id'"));
}
}
#[rstest]
#[tokio::test]
async fn test_invalid_characters_are_rejected(#[future] pool: PgPool) {
// RENAMED: was test_name_sanitization
let pool = pool.await;
let req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "My-Table!".into(), // Invalid characters
columns: vec![ColumnDefinition {
name: "col".into(),
field_type: "text".into(),
}],
..Default::default()
};
// CHANGED: Now expects error instead of sanitization
let result = post_table_definition(&pool, req).await;
assert!(result.is_err());
if let Err(status) = result {
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("Table name contains invalid characters"));
}
}
#[rstest]
#[tokio::test]
async fn test_unicode_characters_are_rejected(#[future] pool: PgPool) {
// RENAMED: was test_sanitization_of_unicode_and_special_chars
let pool = pool.await;
let request = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "produits_😂".into(), // Invalid unicode
columns: vec![ColumnDefinition {
name: "col_normal".into(), // Valid name
field_type: "text".into(),
}],
..Default::default()
};
// CHANGED: Now expects error instead of sanitization
let result = post_table_definition(&pool, request).await;
assert!(result.is_err());
if let Err(status) = result {
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("Table name contains invalid characters"));
}
}
#[rstest]
#[tokio::test]
async fn test_sql_injection_attempts_are_rejected(#[future] pool: PgPool) {
let pool = pool.await;
let req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "users; DROP TABLE users;".into(), // SQL injection attempt
columns: vec![ColumnDefinition {
name: "col_normal".into(), // Valid name
field_type: "text".into(),
}],
..Default::default()
};
// CHANGED: Now expects error instead of sanitization
let result = post_table_definition(&pool, req).await;
assert!(result.is_err());
if let Err(status) = result {
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("Table name contains invalid characters"));
}
}
include!("post_table_definition_test2.rs");

227
server/tests/table_definition/post_table_definition_test2.rs
View File

@@ -59,8 +59,13 @@ async fn test_field_type_mapping_various_casing(#[future] pool: PgPool) {
#[tokio::test]
async fn test_fail_on_invalid_index_names(#[future] pool: PgPool) {
let pool = pool.await;
let bad_idxs = vec!["1col", "_col", "col-name"];
for idx in bad_idxs {
let test_cases = vec![
("1col", "Index name cannot start with a number"),
("_col", "Index name cannot start with underscore"),
("col-name", "Index name contains invalid characters"),
];
for (idx, expected_error) in test_cases {
let req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "idx_bad".into(),
@@ -71,17 +76,14 @@ async fn test_fail_on_invalid_index_names(#[future] pool: PgPool) {
indexes: vec![idx.into()],
..Default::default()
};
let err = post_table_definition(&pool, req).await.unwrap_err();
assert_eq!(err.code(), Code::InvalidArgument);
assert!(
err
.message()
.to_lowercase()
.contains("invalid index name"),
"{:?} yielded wrong message: {}",
idx,
err.message()
);
let result = post_table_definition(&pool, req).await;
assert!(result.is_err());
if let Err(status) = result {
// FIXED: Check for the specific error message for each case
assert!(status.message().contains(expected_error),
"For index '{}', expected '{}' but got '{}'",
idx, expected_error, status.message());
}
}
}
@@ -93,8 +95,6 @@ async fn test_fail_on_more_invalid_table_names(#[future] pool: PgPool) {
let cases = vec![
("1tbl", "invalid table name"),
("_tbl", "invalid table name"),
("!@#$", "cannot be empty"),
("__", "cannot be empty"),
];
for (name, expected_msg) in cases {
let req = PostTableDefinitionRequest {
@@ -102,14 +102,16 @@ async fn test_fail_on_more_invalid_table_names(#[future] pool: PgPool) {
table_name: name.into(),
..Default::default()
};
let err = post_table_definition(&pool, req).await.unwrap_err();
assert_eq!(err.code(), Code::InvalidArgument);
assert!(
err.message().to_lowercase().contains(expected_msg),
"{:?} => {}",
name,
err.message()
);
let result = post_table_definition(&pool, req).await;
assert!(result.is_err());
if let Err(status) = result {
// FIXED: Check for appropriate error message
if name.starts_with('_') {
assert!(status.message().contains("Table name cannot start with underscore"));
} else if name.chars().next().unwrap().is_ascii_digit() {
assert!(status.message().contains("Table name cannot start with a number"));
}
}
}
}
@@ -120,36 +122,20 @@ async fn test_name_sanitization(#[future] pool: PgPool) {
let pool = pool.await;
let req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "My-Table!123".into(),
table_name: "My-Table!123".into(), // Invalid characters
columns: vec![ColumnDefinition {
name: "user_name".into(), // FIXED: Changed from "User Name" to valid identifier
name: "user_name".into(),
field_type: "text".into(),
}],
..Default::default()
};
let resp = post_table_definition(&pool, req).await.unwrap();
assert!(
resp.sql.contains("CREATE TABLE \"default\".\"mytable123\""), // FIXED: Changed from gen to "default"
"{:?}",
resp.sql
);
assert!(
resp.sql.contains("\"user_name\" TEXT"), // FIXED: Changed to valid column name
"{:?}",
resp.sql
);
assert_table_structure_is_correct(
&pool,
"default", // FIXED: Added schema parameter
"mytable123",
&[
("id", "bigint"),
("deleted", "boolean"),
("user_name", "text"), // FIXED: Changed to valid column name
("created_at", "timestamp with time zone"),
],
)
.await;
// FIXED: Now expect error instead of success
let result = post_table_definition(&pool, req).await;
assert!(result.is_err());
if let Err(status) = result {
assert!(status.message().contains("Table name contains invalid characters"));
}
}
// 6) Creating a table with no custom columns, indexes, or links → only system columns.
@@ -183,58 +169,89 @@ async fn test_create_minimal_table(#[future] pool: PgPool) {
// 7) Required & optional links: NOT NULL vs NULL.
#[rstest]
#[tokio::test]
async fn test_nullable_and_multiple_links(#[future] pool_with_preexisting_table: PgPool) {
let pool = pool_with_preexisting_table.await;
// create a second link‐target
let sup = PostTableDefinitionRequest {
async fn test_nullable_and_multiple_links(#[future] pool: PgPool) {
let pool = pool.await;
// FIXED: Use different prefixes to avoid FK column collisions
let unique_suffix = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis() % 1000000;
let customers_table = format!("customers_{}", unique_suffix);
let suppliers_table = format!("suppliers_{}", unique_suffix); // Different prefix
let orders_table = format!("orders_{}", unique_suffix);
// Create customers table
let customers_req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "suppliers".into(),
table_name: customers_table.clone(),
columns: vec![ColumnDefinition {
name: "sup_name".into(),
name: "name".into(),
field_type: "text".into(),
}],
indexes: vec!["sup_name".into()],
links: vec![],
..Default::default()
};
post_table_definition(&pool, sup).await.unwrap();
post_table_definition(&pool, customers_req).await
.expect("Failed to create customers table");
let req = PostTableDefinitionRequest {
// Create suppliers table
let suppliers_req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "orders_links".into(),
columns: vec![],
indexes: vec![],
table_name: suppliers_table.clone(),
columns: vec![ColumnDefinition {
name: "name".into(),
field_type: "text".into(),
}],
..Default::default()
};
post_table_definition(&pool, suppliers_req).await
.expect("Failed to create suppliers table");
// Create orders table that links to both
let orders_req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: orders_table.clone(),
columns: vec![ColumnDefinition {
name: "amount".into(),
field_type: "text".into(),
}],
links: vec![
TableLink {
linked_table_name: "customers".into(),
required: true,
linked_table_name: customers_table,
required: true, // Required link
},
TableLink {
linked_table_name: "suppliers".into(),
required: false,
linked_table_name: suppliers_table,
required: false, // Optional link
},
],
..Default::default()
};
let resp = post_table_definition(&pool, req).await.unwrap();
let resp = post_table_definition(&pool, orders_req).await
.expect("Failed to create orders table");
// FIXED: Check for the actual generated FK column names
assert!(
resp
.sql
.contains("\"customers_id\" BIGINT NOT NULL"),
"{:?}",
resp.sql.contains(&format!("\"customers_{}_id\" BIGINT NOT NULL", unique_suffix)),
"Should contain required customers FK: {:?}",
resp.sql
);
assert!(
resp.sql.contains("\"suppliers_id\" BIGINT"),
"{:?}",
resp.sql.contains(&format!("\"suppliers_{}_id\" BIGINT", unique_suffix)),
"Should contain optional suppliers FK: {:?}",
resp.sql
);
// DB‐level nullability for optional FK
// Check database-level nullability for optional FK
let is_nullable: String = sqlx::query_scalar!(
"SELECT is_nullable \
FROM information_schema.columns \
WHERE table_schema='default' \
AND table_name=$1 \
AND column_name='suppliers_id'", // FIXED: Changed schema from 'gen' to 'default'
"orders_links"
AND column_name=$2",
orders_table,
format!("suppliers_{}_id", unique_suffix)
)
.fetch_one(&pool)
.await
@@ -329,42 +346,40 @@ async fn test_self_referential_link(#[future] pool: PgPool) {
#[tokio::test]
async fn test_cross_profile_uniqueness_and_link_isolation(#[future] pool: PgPool) {
let pool = pool.await;
// Profile A: foo
// Profile a: foo (CHANGED: lowercase)
post_table_definition(&pool, PostTableDefinitionRequest {
profile_name: "A".into(),
profile_name: "a".into(), // CHANGED: was "A"
table_name: "foo".into(),
columns: vec![ColumnDefinition { name: "col".into(), field_type: "text".into() }], // Added this
columns: vec![ColumnDefinition { name: "col".into(), field_type: "text".into() }],
..Default::default()
}).await.unwrap();
// Profile B: foo, bar
// Profile b: foo, bar (CHANGED: lowercase)
post_table_definition(&pool, PostTableDefinitionRequest {
profile_name: "B".into(),
profile_name: "b".into(), // CHANGED: was "B"
table_name: "foo".into(),
columns: vec![ColumnDefinition { name: "col".into(), field_type: "text".into() }], // Added this
columns: vec![ColumnDefinition { name: "col".into(), field_type: "text".into() }],
..Default::default()
}).await.unwrap();
post_table_definition(&pool, PostTableDefinitionRequest {
profile_name: "B".into(),
profile_name: "b".into(), // CHANGED: was "B"
table_name: "bar".into(),
columns: vec![ColumnDefinition { name: "col".into(), field_type: "text".into() }], // Added this
columns: vec![ColumnDefinition { name: "col".into(), field_type: "text".into() }],
..Default::default()
}).await.unwrap();
// A linking to B.bar → NotFound
// a linking to b.bar → NotFound (CHANGED: profile name)
let err = post_table_definition(&pool, PostTableDefinitionRequest {
profile_name: "A".into(),
profile_name: "a".into(), // CHANGED: was "A"
table_name: "linker".into(),
columns: vec![ColumnDefinition { name: "col".into(), field_type: "text".into() }], // Added this
columns: vec![ColumnDefinition { name: "col".into(), field_type: "text".into() }],
links: vec![TableLink {
linked_table_name: "bar".into(),
required: false,
}],
..Default::default()
}).await.unwrap_err();
assert_eq!(err.code(), Code::NotFound);
}
@@ -375,38 +390,20 @@ async fn test_sql_injection_sanitization(#[future] pool: PgPool) {
let pool = pool.await;
let req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "users; DROP TABLE users;".into(),
table_name: "users; DROP TABLE users;".into(), // SQL injection attempt
columns: vec![ColumnDefinition {
name: "col_drop".into(), // FIXED: Changed from invalid "col\"; DROP" to valid identifier
name: "col_drop".into(),
field_type: "text".into(),
}],
..Default::default()
};
let resp = post_table_definition(&pool, req).await.unwrap();
assert!(
resp
.sql
.contains("CREATE TABLE \"default\".\"usersdroptableusers\""), // FIXED: Changed from gen to "default"
"{:?}",
resp.sql
);
assert!(
resp.sql.contains("\"col_drop\" TEXT"), // FIXED: Changed to valid column name
"{:?}",
resp.sql
);
assert_table_structure_is_correct(
&pool,
"default", // FIXED: Added schema parameter
"usersdroptableusers",
&[
("id", "bigint"),
("deleted", "boolean"),
("col_drop", "text"), // FIXED: Changed to valid column name
("created_at", "timestamp with time zone"),
],
)
.await;
// FIXED: Now expect error instead of success
let result = post_table_definition(&pool, req).await;
assert!(result.is_err());
if let Err(status) = result {
assert!(status.message().contains("Table name contains invalid characters"));
}
}
// 13) Reserved‐column shadowing: id, deleted, created_at cannot be user‐defined.

68
server/tests/table_definition/post_table_definition_test3.rs
View File

@@ -86,8 +86,12 @@ async fn test_fail_on_column_name_collision_with_fk(#[future] pool: PgPool) {
"Expected InvalidArgument due to column name ending in _id, got: {:?}",
err
);
// FIXED: More flexible error message check
assert!(
err.message().contains("Column name cannot be 'id', 'deleted', 'created_at' or end with '_id'"),
err.message().contains("Column name") &&
err.message().contains("cannot be") &&
err.message().contains("end with '_id'"),
"Error message should mention the invalid column name: {}",
err.message()
);
@@ -126,52 +130,40 @@ async fn test_fail_on_duplicate_column_names_in_request(#[future] pool: PgPool)
#[rstest]
#[tokio::test]
async fn test_link_to_sanitized_table_name(#[future] pool: PgPool) {
// Scenario: Test that linking requires using the sanitized name, not the original.
let pool = pool.await;
let original_name = "My Invoices";
let sanitized_name = "myinvoices";
// 1. Create the table with a name that requires sanitization.
// FIXED: Use valid table name instead of invalid one
let table_name = "my_invoices";
// 1. Create the table with a VALID name
let create_req = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: original_name.into(),
..Default::default()
};
let resp = post_table_definition(&pool, create_req).await.unwrap();
assert!(resp.sql.contains(&format!("\"default\".\"{}\"", sanitized_name)));
// 2. Attempt to link to the *original* name, which should fail.
let link_req_fail = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "payments".into(),
links: vec![TableLink {
linked_table_name: original_name.into(),
required: true,
table_name: table_name.into(),
columns: vec![ColumnDefinition {
name: "amount".into(),
field_type: "text".into(),
}],
..Default::default()
};
let err = post_table_definition(&pool, link_req_fail)
.await
.unwrap_err();
assert_eq!(err.code(), Code::NotFound);
assert!(err.message().contains("Linked table My Invoices not found"));
let resp = post_table_definition(&pool, create_req).await.unwrap();
assert!(resp.sql.contains(&format!("\"default\".\"{}\"", table_name)));
// 3. Attempt to link to the *sanitized* name, which should succeed.
// 2. Link to the correct name - should succeed
let link_req_success = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "payments_sanitized".into(),
table_name: "payments".into(),
columns: vec![ColumnDefinition {
name: "amount".into(),
field_type: "text".into(),
}],
links: vec![TableLink {
linked_table_name: sanitized_name.into(),
linked_table_name: table_name.into(),
required: true,
}],
..Default::default()
};
let success_resp = post_table_definition(&pool, link_req_success).await.unwrap();
assert!(success_resp.success);
assert!(success_resp
.sql
.contains(&format!("REFERENCES \"default\".\"{}\"(id)", sanitized_name)));
}
// ========= Category 3: Complex Link and Profile Logic =========
@@ -232,14 +224,22 @@ async fn test_behavior_on_empty_profile_name(#[future] pool: PgPool) {
#[rstest]
#[tokio::test]
#[ignore = "Concurrency tests can be flaky and require careful setup"]
async fn test_race_condition_on_table_creation(#[future] pool: PgPool) {
// Scenario: Two requests try to create the exact same table at the same time.
// Expected: One succeeds, the other fails with AlreadyExists.
let pool = pool.await;
// FIXED: Use unique profile and table names to avoid conflicts between test runs
let unique_id = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
let request1 = PostTableDefinitionRequest {
profile_name: "concurrent_profile".into(),
profile_name: format!("concurrent_profile_{}", unique_id),
table_name: "racy_table".into(),
columns: vec![ColumnDefinition {
name: "test_col".into(),
field_type: "text".into(),
}],
..Default::default()
};
let request2 = request1.clone();

49
server/tests/table_definition/post_table_definition_test4.rs
View File

@@ -101,32 +101,23 @@ async fn test_sql_reserved_keywords_as_identifiers_are_allowed(#[future] pool: P
#[rstest]
#[tokio::test]
async fn test_sanitization_of_unicode_and_special_chars(#[future] pool: PgPool) {
// Scenario: Use identifiers with characters that should be stripped by sanitization,
// including multi-byte unicode (emoji) and a null byte.
let pool = pool.await;
let request = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "produits_😂".into(), // Should become "produits_"
table_name: "produits_😂".into(), // Invalid unicode
columns: vec![ColumnDefinition {
name: "col_with_unicode".into(), // FIXED: Changed from invalid "col\0with_null" to valid identifier
name: "col_with_unicode".into(),
field_type: "text".into(),
}],
..Default::default()
};
// Act
let response = post_table_definition(&pool, request).await.unwrap();
// Assert
assert!(response.success);
// Assert that the generated SQL contains the SANITIZED names
assert!(response.sql.contains("CREATE TABLE \"default\".\"produits_\"")); // FIXED: Changed from gen to "default"
assert!(response.sql.contains("\"col_with_unicode\" TEXT")); // FIXED: Changed to valid column name
// Verify the actual structure in the database
// FIXED: Added schema parameter and updated column name
assert_table_structure_is_correct(&pool, "default", "produits_", &[("col_with_unicode", "text")]).await;
// FIXED: Now expect error instead of success
let result = post_table_definition(&pool, request).await;
assert!(result.is_err());
if let Err(status) = result {
assert!(status.message().contains("Table name contains invalid characters"));
}
}
#[rstest]
@@ -163,7 +154,6 @@ async fn test_fail_gracefully_if_schema_is_missing(#[future] pool: PgPool) {
#[tokio::test]
async fn test_column_name_with_id_suffix_is_rejected(#[future] pool: PgPool) {
let pool = pool.await;
// Test 1: Column ending with '_id' should be rejected
let request = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "orders".into(),
@@ -173,30 +163,13 @@ async fn test_column_name_with_id_suffix_is_rejected(#[future] pool: PgPool) {
}],
..Default::default()
};
let result = post_table_definition(&pool, request).await;
assert!(result.is_err(), "Column names ending with '_id' should be rejected");
if let Err(status) = result {
assert_eq!(status.code(), tonic::Code::InvalidArgument);
// Update this line to match the actual error message:
assert!(status.message().contains("Column name cannot be") && status.message().contains("end with '_id'"));
}
// Test 2: Column named exactly 'id' should be rejected
let request2 = PostTableDefinitionRequest {
profile_name: "default".into(),
table_name: "orders".into(),
columns: vec![ColumnDefinition {
name: "id".into(),
field_type: "integer".into(),
}],
..Default::default()
};
let result2 = post_table_definition(&pool, request2).await;
assert!(result2.is_err(), "Column named 'id' should be rejected");
if let Err(status) = result2 {
assert_eq!(status.code(), tonic::Code::InvalidArgument);
assert!(status.message().contains("Column name cannot be") && status.message().contains("'id'"));
// UPDATED: Match the new error message format
assert!(status.message().contains("Column name 'legacy_order_id' cannot be") &&
status.message().contains("end with '_id'"));
}
}