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

235
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();
let req = PostTableDefinitionRequest {
post_table_definition(&pool, customers_req).await
.expect("Failed to create customers table");
// 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.