mirror of
https://github.com/fawney19/Aether.git
synced 2026-10-04 00:17:45 +08:00
AAEE86
3394a51278
第一批减负（对应 docs/operations/gateway-ci-timeout-reduction-plan.md）： A1 架构守卫迁出 - 将 src/tests/architecture/**（208 项 / 约 1.5 万行字符串断言）迁至 tests/architecture/，入口 tests/architecture_guard.rs - 从 lib cfg(test) 巨型编译单元移除，压低 rustc 峰值与 OOM 风险 - 断言逻辑不变；helper 可见性改为 pub(crate) A2 构建指纹统一 - test_gateway 的 mold RUSTFLAGS / RUST_MIN_STACK / sccache 上移至 job 级 env - rust-ci.yml 全部 toolchain 钉住 1.95.0（与 rust-toolchain.toml、fmt/clippy 一致） - Gateway 独立 cache key，避免 mold 指纹与无 mold job 互相污染 A4 补安全集成测试 - 新增 Test integration targets：cargo nextest run -p aether-gateway --tests - 覆盖 architecture_guard + 此前未执行的 admin_unsigned_identity_headers 验证：architecture_guard + admin_unsigned 209 passed； cargo check -p aether-gateway --lib --tests 通过；cargo fmt --check 通过。 不创建 PR，仅本地分支提交。
2119 lines
76 KiB
Rust
2119 lines
76 KiB
Rust
use super::*;
|
|
|
|
fn production_source(source: &str) -> &str {
|
|
source.split("#[cfg(test)]").next().unwrap_or(source)
|
|
}
|
|
|
|
#[test]
|
|
fn handlers_do_not_inline_sql_queries() {
|
|
assert_no_sqlx_queries("src/handlers");
|
|
}
|
|
|
|
#[test]
|
|
fn gateway_runtime_does_not_inline_sql_queries() {
|
|
assert_no_sqlx_queries("src/state/runtime");
|
|
}
|
|
|
|
#[test]
|
|
fn aether_data_bootstrap_snapshot_is_built_from_schema_sources() {
|
|
let build_rs = read_workspace_file("crates/aether-data/runtime/build.rs");
|
|
assert!(
|
|
build_rs.contains("schema/bootstrap/postgres/manifest.txt"),
|
|
"build.rs should source the bootstrap snapshot from schema/bootstrap/postgres"
|
|
);
|
|
|
|
let compose_schema = read_workspace_file("crates/aether-data/runtime/schema/compose_schema.sh");
|
|
assert!(
|
|
compose_schema.contains("check_bootstrap_sources"),
|
|
"compose_schema.sh should still validate bootstrap source fragments"
|
|
);
|
|
assert!(
|
|
!compose_schema.contains("bootstrap/postgres/20260413020000_empty_database_snapshot.sql"),
|
|
"compose_schema.sh should not depend on the outer bootstrap artifact anymore"
|
|
);
|
|
|
|
let bootstrap =
|
|
read_workspace_file("crates/aether-data/runtime/src/lifecycle/bootstrap/postgres.rs");
|
|
assert!(
|
|
bootstrap
|
|
.contains("include_str!(concat!(env!(\"OUT_DIR\"), \"/empty_database_snapshot.sql\"))"),
|
|
"lifecycle/bootstrap/postgres.rs should embed the generated bootstrap snapshot from OUT_DIR"
|
|
);
|
|
assert!(
|
|
!bootstrap
|
|
.contains("../../../bootstrap/postgres/20260413020000_empty_database_snapshot.sql"),
|
|
"lifecycle/bootstrap/postgres.rs should not read the outer bootstrap artifact directly"
|
|
);
|
|
|
|
let provider_catalog =
|
|
read_workspace_file("crates/aether-data/adapters/postgres/src/provider_catalog.rs");
|
|
assert!(
|
|
!provider_catalog
|
|
.contains("../../../bootstrap/postgres/20260413020000_empty_database_snapshot.sql"),
|
|
"provider_catalog tests should use the shared bootstrap snapshot constant instead of the outer bootstrap artifact"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn aether_data_backend_pool_modules_do_not_own_maintenance_sql() {
|
|
for path in ["crates/aether-data/runtime/src/backend/postgres.rs"] {
|
|
let source = read_workspace_file(path);
|
|
let production = production_source(&source);
|
|
for forbidden in [
|
|
"run_table_maintenance(",
|
|
"aggregate_wallet_daily_usage(",
|
|
"aggregate_stats_hourly(",
|
|
"aggregate_stats_daily(",
|
|
"find_system_config_value(",
|
|
"list_system_config_entries(",
|
|
"upsert_system_config_entry(",
|
|
"read_admin_system_stats(",
|
|
"sqlx::query(",
|
|
"sqlx::query_scalar",
|
|
"sqlx::raw_sql(",
|
|
] {
|
|
assert!(
|
|
!production.contains(forbidden),
|
|
"{path} should stay focused on pool and repository construction instead of owning maintenance SQL via {forbidden}"
|
|
);
|
|
}
|
|
}
|
|
|
|
let maintenance = read_workspace_file("crates/aether-data/runtime/src/backend/maintenance.rs");
|
|
for pattern in [
|
|
"Self::Postgres(postgres) => postgres.run_table_maintenance(table_names).await",
|
|
"Self::Postgres(postgres) => postgres.aggregate_wallet_daily_usage(input).await",
|
|
"Self::Postgres(postgres) => postgres.aggregate_stats_hourly(input).await",
|
|
"Self::Postgres(postgres) => postgres.aggregate_stats_daily(input).await",
|
|
] {
|
|
assert!(
|
|
maintenance.contains(pattern),
|
|
"backend/maintenance.rs should own SQL-driver maintenance dispatch {pattern}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn wallet_maintenance_sql_is_partitioned_by_driver() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/backend/wallet.rs");
|
|
let module = "mod postgres;";
|
|
assert!(
|
|
facade.contains(module),
|
|
"wallet facade should declare {module}"
|
|
);
|
|
for forbidden in [
|
|
"sqlx::",
|
|
"PostgresBackend",
|
|
"SELECT ",
|
|
"INSERT INTO ",
|
|
"DELETE FROM ",
|
|
] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"wallet facade should not own driver implementation via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let (driver, backend) = ("postgres", "PostgresBackend");
|
|
let path = format!("crates/aether-data/runtime/src/backend/wallet/{driver}.rs");
|
|
let source = read_workspace_file(&path);
|
|
assert!(source.contains(&format!("impl {backend}")));
|
|
assert!(source.contains("aggregate_wallet_daily_usage"));
|
|
assert!(source.contains("sqlx::query"));
|
|
}
|
|
|
|
#[test]
|
|
fn table_maintenance_is_partitioned_for_each_driver() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/backend/maintenance.rs");
|
|
let module = "mod postgres;";
|
|
assert!(
|
|
facade.contains(module),
|
|
"maintenance facade should declare {module}"
|
|
);
|
|
for forbidden in [
|
|
"impl PostgresBackend",
|
|
"VACUUM ANALYZE",
|
|
"ANALYZE TABLE",
|
|
"PRAGMA optimize",
|
|
"sqlx::Row",
|
|
] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"maintenance dispatch should not own driver SQL via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let postgres =
|
|
read_workspace_file("crates/aether-data/runtime/src/backend/maintenance/postgres.rs");
|
|
assert!(postgres.contains("impl PostgresBackend"));
|
|
assert!(postgres.contains("postgres_observability_snapshot"));
|
|
assert!(postgres.contains("VACUUM ANALYZE"));
|
|
}
|
|
|
|
#[test]
|
|
fn system_driver_database_operations_are_partitioned() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/backend/system.rs");
|
|
let module = "mod postgres;";
|
|
assert!(
|
|
facade.contains(module),
|
|
"system facade should declare {module}"
|
|
);
|
|
for forbidden in [
|
|
"impl PostgresBackend",
|
|
"fn map_postgres_stats_daily_aggregate(",
|
|
"fn map_postgres_stats_user_daily_aggregate(",
|
|
"async fn export_postgres_admin_system_usage_aggregates(",
|
|
"async fn import_postgres_admin_system_usage_aggregates(",
|
|
"async fn pg_delete_table(",
|
|
"async fn pg_execute_if_table(",
|
|
"async fn pg_execute_batch_if_table(",
|
|
"async fn pg_table_exists(",
|
|
"async fn purge_postgres_admin_system_data(",
|
|
"async fn purge_postgres_non_admin_users(",
|
|
"async fn purge_postgres_request_bodies_batch(",
|
|
] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"system facade should not own driver database operations via {forbidden}"
|
|
);
|
|
}
|
|
|
|
for driver in ["postgres"] {
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/runtime/src/backend/system/{driver}.rs"
|
|
));
|
|
let backend = match driver {
|
|
"postgres" => "Postgres",
|
|
|
|
_ => unreachable!(),
|
|
};
|
|
for required in [
|
|
format!("impl {backend}Backend"),
|
|
"map_stats_daily_aggregate".to_string(),
|
|
"map_stats_user_daily_aggregate".to_string(),
|
|
"map_stats_daily_api_key_aggregate".to_string(),
|
|
"map_admin_system_stats".to_string(),
|
|
format!("export_{driver}_admin_system_usage_aggregates"),
|
|
format!("import_{driver}_admin_system_usage_aggregates"),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"system/{driver}.rs should own {required}"
|
|
);
|
|
}
|
|
if driver == "postgres" {
|
|
for required in [
|
|
"pg_delete_table",
|
|
"pg_execute_if_table",
|
|
"pg_execute_batch_if_table",
|
|
"pg_table_exists",
|
|
"purge_postgres_admin_system_data",
|
|
"purge_postgres_non_admin_users",
|
|
"purge_postgres_request_bodies_batch",
|
|
] {
|
|
assert!(
|
|
source.contains(required),
|
|
"system/postgres.rs should own {required}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn audit_repository_database_operations_are_partitioned() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/audit.rs");
|
|
for module in ["mod types;", "mod tests;"] {
|
|
assert!(
|
|
facade.contains(module),
|
|
"audit facade should declare {module}"
|
|
);
|
|
}
|
|
for forbidden in [
|
|
"sqlx::",
|
|
"PostgresPool",
|
|
"impl AuditLogReadRepository",
|
|
"SELECT ",
|
|
"DELETE FROM ",
|
|
] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"audit facade should not own driver database operations via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let types = read_workspace_file("crates/aether-data/contracts/src/repository/audit.rs");
|
|
for required in [
|
|
"pub trait AuditLogReadRepository",
|
|
"pub struct StoredAdminAuditLog",
|
|
"pub struct StoredSuspiciousActivity",
|
|
"pub struct StoredUserAuditLog",
|
|
"pub const SUSPICIOUS_EVENT_TYPES",
|
|
] {
|
|
assert!(
|
|
types.contains(required),
|
|
"aether-data-contracts audit.rs should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool"] {
|
|
assert!(
|
|
!types.contains(forbidden),
|
|
"aether-data-contracts audit.rs should remain driver-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
let request_types =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/audit/types.rs");
|
|
for required in [
|
|
"pub trait RequestAuditReader",
|
|
"pub struct RequestAuditBundle",
|
|
"pub async fn read_request_audit_bundle",
|
|
] {
|
|
assert!(
|
|
request_types.contains(required),
|
|
"aether-data request audit types should own {required}"
|
|
);
|
|
}
|
|
|
|
for (driver, repository, row_mapper) in [(
|
|
"postgres",
|
|
"PostgresAuditLogReadRepository",
|
|
"map_postgres_admin_audit_log_row",
|
|
)] {
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{driver}/src/audit.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl AuditLogReadRepository for {repository}"),
|
|
row_mapper.to_string(),
|
|
"sqlx::query".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{driver}/src/audit.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/audit/{driver}.rs"
|
|
)),
|
|
"audit SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn auth_module_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/auth_modules/mod.rs");
|
|
for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"auth module facade should not own contracts or driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/auth_modules.rs");
|
|
for required in [
|
|
"pub struct StoredOAuthProviderModuleConfig",
|
|
"pub struct StoredLdapModuleConfig",
|
|
"pub trait AuthModuleReadRepository",
|
|
"pub trait AuthModuleWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"aether-data-contracts auth_modules.rs should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool"] {
|
|
assert!(
|
|
!contracts.contains(forbidden),
|
|
"auth module contracts should remain driver-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, read_repository, write_repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxAuthModuleReadRepository",
|
|
"SqlxAuthModuleRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
|
|
"auth module facade should preserve the {feature} feature boundary"
|
|
);
|
|
assert!(
|
|
facade.contains(&format!(
|
|
"pub use {adapter}::{{{read_repository}, {write_repository}}};"
|
|
)),
|
|
"auth module facade should re-export {feature} repositories from its adapter"
|
|
);
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/auth_modules.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {read_repository}"),
|
|
format!("pub struct {write_repository}"),
|
|
format!("impl AuthModuleReadRepository for {read_repository}"),
|
|
format!("impl AuthModuleWriteRepository for {write_repository}"),
|
|
"sqlx::query".to_string(),
|
|
"ldap_configs".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/auth_modules.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/auth_modules/{feature}.rs"
|
|
)),
|
|
"auth module SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists("crates/aether-data/runtime/src/repository/auth_modules/types.rs"),
|
|
"auth module contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn announcement_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/announcements/mod.rs");
|
|
for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"announcement facade should not own contracts or driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/announcements.rs");
|
|
for required in [
|
|
"pub struct StoredAnnouncement",
|
|
"pub struct AnnouncementListQuery",
|
|
"pub struct CreateAnnouncementRecord",
|
|
"pub struct UpdateAnnouncementRecord",
|
|
"pub trait AnnouncementReadRepository",
|
|
"pub trait AnnouncementWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"aether-data-contracts announcements.rs should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool"] {
|
|
assert!(
|
|
!contracts.contains(forbidden),
|
|
"announcement contracts should remain driver-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxAnnouncementReadRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
|
|
"announcement facade should preserve the {feature} feature boundary"
|
|
);
|
|
assert!(
|
|
facade.contains(&format!("pub use {adapter}::{repository};")),
|
|
"announcement facade should re-export {feature} repository from its adapter"
|
|
);
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/announcements.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl AnnouncementReadRepository for {repository}"),
|
|
format!("impl AnnouncementWriteRepository for {repository}"),
|
|
"sqlx::query".to_string(),
|
|
"announcement_reads".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/announcements.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/announcements/{feature}.rs"
|
|
)),
|
|
"announcement SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists("crates/aether-data/runtime/src/repository/announcements/types.rs"),
|
|
"announcement contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn oauth_provider_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/oauth_providers/mod.rs");
|
|
for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"oauth provider facade should not own contracts or driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/oauth_providers.rs");
|
|
for required in [
|
|
"pub struct StoredOAuthProviderConfig",
|
|
"pub enum EncryptedSecretUpdate",
|
|
"pub struct UpsertOAuthProviderConfigRecord",
|
|
"pub trait OAuthProviderReadRepository",
|
|
"pub trait OAuthProviderWriteRepository",
|
|
"pub trait OAuthProviderRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"aether-data-contracts oauth_providers.rs should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool"] {
|
|
assert!(
|
|
!contracts.contains(forbidden),
|
|
"oauth provider contracts should remain driver-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxOAuthProviderRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
|
|
"oauth provider facade should preserve the {feature} feature boundary"
|
|
);
|
|
assert!(
|
|
facade.contains(&format!("pub use {adapter}::{repository};")),
|
|
"oauth provider facade should re-export {feature} repository from its adapter"
|
|
);
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/oauth_providers.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl OAuthProviderReadRepository for {repository}"),
|
|
format!("impl OAuthProviderWriteRepository for {repository}"),
|
|
"oauth_providers".to_string(),
|
|
"sqlx::query".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/oauth_providers.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/oauth_providers/{feature}.rs"
|
|
)),
|
|
"oauth provider SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(
|
|
"crates/aether-data/runtime/src/repository/oauth_providers/types.rs"
|
|
),
|
|
"oauth provider contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn management_token_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/management_tokens/mod.rs");
|
|
for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"management token facade should not own contracts or driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/management_tokens.rs");
|
|
for required in [
|
|
"pub struct StoredManagementToken",
|
|
"pub struct StoredManagementTokenUserSummary",
|
|
"pub struct CreateManagementTokenRecord",
|
|
"pub struct UpdateManagementTokenRecord",
|
|
"pub trait ManagementTokenReadRepository",
|
|
"pub trait ManagementTokenWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"aether-data-contracts management_tokens.rs should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool"] {
|
|
assert!(
|
|
!contracts.contains(forbidden),
|
|
"management token contracts should remain driver-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxManagementTokenRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
|
|
"management token facade should preserve the {feature} feature boundary"
|
|
);
|
|
assert!(
|
|
facade.contains(&format!("pub use {adapter}::{repository};")),
|
|
"management token facade should re-export {feature} repository from its adapter"
|
|
);
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/management_tokens.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl ManagementTokenReadRepository for {repository}"),
|
|
format!("impl ManagementTokenWriteRepository for {repository}"),
|
|
"management_tokens".to_string(),
|
|
"sqlx::query".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/management_tokens.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/management_tokens/{feature}.rs"
|
|
)),
|
|
"management token SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(
|
|
"crates/aether-data/runtime/src/repository/management_tokens/types.rs"
|
|
),
|
|
"management token contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gemini_file_mapping_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade = read_workspace_file(
|
|
"crates/aether-data/runtime/src/repository/gemini_file_mappings/mod.rs",
|
|
);
|
|
for forbidden in ["sqlx::", "QueryBuilder", "PgPool"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"gemini file mapping facade should not own driver code via {forbidden}"
|
|
);
|
|
}
|
|
assert!(
|
|
facade.contains("pub use aether_data_contracts::repository::gemini_file_mappings::*;"),
|
|
"legacy types path should remain a contracts-backed compatibility facade"
|
|
);
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/gemini_file_mappings.rs");
|
|
for required in [
|
|
"pub struct StoredGeminiFileMapping",
|
|
"pub struct GeminiFileMappingListQuery",
|
|
"pub struct UpsertGeminiFileMappingRecord",
|
|
"pub trait GeminiFileMappingReadRepository",
|
|
"pub trait GeminiFileMappingWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"aether-data-contracts gemini_file_mappings.rs should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool"] {
|
|
assert!(
|
|
!contracts.contains(forbidden),
|
|
"gemini file mapping contracts should remain driver-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxGeminiFileMappingRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("pub use {adapter}::{repository};")),
|
|
"gemini file mapping facade should re-export {feature} repository from its adapter"
|
|
);
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/gemini_file_mappings.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl GeminiFileMappingReadRepository for {repository}"),
|
|
format!("impl GeminiFileMappingWriteRepository for {repository}"),
|
|
"gemini_file_mappings".to_string(),
|
|
"sqlx::query".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/gemini_file_mappings.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/gemini_file_mappings/{feature}.rs"
|
|
)),
|
|
"gemini file mapping SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(
|
|
"crates/aether-data/runtime/src/repository/gemini_file_mappings/types.rs"
|
|
),
|
|
"gemini file mapping contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn video_task_repositories_are_owned_by_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/video_tasks/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"video task facade should not own driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/video_tasks/types.rs");
|
|
for required in [
|
|
"pub struct StoredVideoTask",
|
|
"pub struct UpsertVideoTask",
|
|
"pub trait VideoTaskReadRepository",
|
|
"pub trait VideoTaskWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"aether-data-contracts video task types should own {required}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repositories) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
vec!["SqlxVideoTaskReadRepository", "SqlxVideoTaskRepository"],
|
|
)] {
|
|
for repository in repositories {
|
|
assert!(
|
|
facade.contains(repository) && facade.contains(adapter),
|
|
"video task facade should re-export {feature} {repository} from its adapter"
|
|
);
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/video_tasks.rs"
|
|
));
|
|
assert!(
|
|
source.contains(repository),
|
|
"aether-data-{feature}/src/video_tasks.rs should own {repository}"
|
|
);
|
|
assert!(source.contains("sqlx::query"));
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/video_tasks/{feature}.rs"
|
|
)),
|
|
"video task SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn candidate_selection_repositories_are_owned_by_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/candidate_selection/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "PgPool"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"candidate selection facade should not own driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts = read_workspace_file(
|
|
"crates/aether-data/contracts/src/repository/candidate_selection/types.rs",
|
|
);
|
|
for required in [
|
|
"pub struct StoredMinimalCandidateSelectionRow",
|
|
"pub trait MinimalCandidateSelectionReadRepository",
|
|
"pub struct StoredPoolKeyCandidateRowsQuery",
|
|
"pub struct StoredRequestedModelCandidateRowsQuery",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"candidate selection contracts should own {required}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxMinimalCandidateSelectionReadRepository",
|
|
)] {
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/candidate_selection.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl MinimalCandidateSelectionReadRepository for {repository}"),
|
|
"provider_api_keys".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/candidate_selection.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/candidate_selection/{feature}.rs"
|
|
)),
|
|
"candidate selection SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn request_candidate_repositories_are_owned_by_driver_adapters() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/candidates/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "PgPool"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"request candidate facade should not own driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/candidates/types.rs");
|
|
for required in [
|
|
"pub struct StoredRequestCandidate",
|
|
"pub struct UpsertRequestCandidateRecord",
|
|
"pub trait RequestCandidateReadRepository",
|
|
"pub trait RequestCandidateWriteRepository",
|
|
"pub fn request_candidate_lifecycle_would_regress",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"request candidate contracts should own {required}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxRequestCandidateReadRepository",
|
|
)] {
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/candidates.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl RequestCandidateReadRepository for {repository}"),
|
|
format!("impl RequestCandidateWriteRepository for {repository}"),
|
|
"request_candidates".to_string(),
|
|
"sqlx::query".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/candidates.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/candidates/{feature}.rs"
|
|
)),
|
|
"request candidate SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn billing_repositories_are_owned_by_driver_adapters() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/billing/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"billing facade should not own driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/billing/types.rs");
|
|
for required in [
|
|
"pub trait BillingReadRepository",
|
|
"pub struct StoredBillingModelContext",
|
|
"pub struct BillingPlanRecord",
|
|
"pub struct AdminBillingRuleRecord",
|
|
"pub struct PaymentGatewayConfigRecord",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"billing contracts should own {required}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxBillingReadRepository",
|
|
)] {
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/billing.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl BillingReadRepository for {repository}"),
|
|
"billing_plans".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/billing.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/billing/{feature}.rs"
|
|
)),
|
|
"billing SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn settlement_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/settlement/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"settlement facade should not own driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/settlement/types.rs");
|
|
for required in [
|
|
"pub trait SettlementWriteRepository",
|
|
"pub struct UsageSettlementInput",
|
|
"pub struct StoredUsageSettlement",
|
|
"pub struct WalletDebitPlan",
|
|
"pub fn plan_finite_wallet_debit",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"settlement contracts should own {required}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxSettlementRepository",
|
|
)] {
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/settlement.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl SettlementWriteRepository for {repository}"),
|
|
"usage_settlement_snapshots".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/settlement.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/settlement/{feature}.rs"
|
|
)),
|
|
"settlement SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn proxy_node_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/proxy_nodes/mod.rs");
|
|
for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"proxy node facade should not own contracts or driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/proxy_nodes.rs");
|
|
for required in [
|
|
"pub struct StoredProxyNode",
|
|
"pub struct ProxyNodeHeartbeatMutation",
|
|
"pub struct StoredProxyNodeMetricsBucket",
|
|
"pub trait ProxyNodeReadRepository",
|
|
"pub trait ProxyNodeWriteRepository",
|
|
"pub fn build_tunnel_metrics_sample",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"proxy node contracts should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool", "tracing::"] {
|
|
assert!(
|
|
!contracts.contains(forbidden),
|
|
"proxy node contracts should remain infrastructure-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxProxyNodeRepository",
|
|
)] {
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/proxy_nodes.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl ProxyNodeReadRepository for {repository}"),
|
|
format!("impl ProxyNodeWriteRepository for {repository}"),
|
|
"proxy_node_metrics_1m".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/proxy_nodes.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/proxy_nodes/{feature}.rs"
|
|
)),
|
|
"proxy node SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists("crates/aether-data/runtime/src/repository/proxy_nodes/types.rs"),
|
|
"proxy node contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn global_model_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/global_models/mod.rs");
|
|
for forbidden in [
|
|
"mod postgres;",
|
|
"sqlx::",
|
|
"QueryBuilder",
|
|
"EMBEDDING_API_FORMATS",
|
|
] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"global model facade should not own driver/query policy via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/global_models/types.rs");
|
|
for required in [
|
|
"pub trait GlobalModelReadRepository",
|
|
"pub trait GlobalModelWriteRepository",
|
|
"pub struct StoredAdminGlobalModel",
|
|
"pub fn metadata_supports_embedding",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"global model contracts should own {required}"
|
|
);
|
|
}
|
|
let snapshot = read_workspace_file(
|
|
"crates/aether-data/contracts/src/repository/global_models/snapshot.rs",
|
|
);
|
|
for required in [
|
|
"pub struct GlobalModelSnapshot",
|
|
"pub fn list_public_models",
|
|
"pub fn list_admin_global_models",
|
|
] {
|
|
assert!(
|
|
snapshot.contains(required),
|
|
"global model snapshot policy should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool", "RwLock"] {
|
|
assert!(
|
|
!snapshot.contains(forbidden),
|
|
"global model snapshot policy should remain infrastructure-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxGlobalModelReadRepository",
|
|
)] {
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/global_models.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl GlobalModelReadRepository for {repository}"),
|
|
format!("impl GlobalModelWriteRepository for {repository}"),
|
|
"global_models".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/global_models.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/global_models/{feature}.rs"
|
|
)),
|
|
"global model SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn auth_api_key_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/auth/mod.rs");
|
|
for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"auth facade should not own contracts or driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts = read_workspace_file("crates/aether-data/contracts/src/repository/auth.rs");
|
|
for required in [
|
|
"pub struct StoredAuthApiKeySnapshot",
|
|
"pub struct ResolvedAuthApiKeySnapshot",
|
|
"pub trait AuthApiKeyReadRepository",
|
|
"pub trait AuthApiKeyWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"auth contracts should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool"] {
|
|
assert!(
|
|
!contracts.contains(forbidden),
|
|
"auth contracts should remain infrastructure-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxAuthApiKeySnapshotReadRepository",
|
|
)] {
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/auth.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl AuthApiKeyReadRepository for {repository}"),
|
|
format!("impl AuthApiKeyWriteRepository for {repository}"),
|
|
"api_keys".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/auth.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/auth/{feature}.rs"
|
|
)),
|
|
"auth SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists("crates/aether-data/runtime/src/repository/auth/types.rs"),
|
|
"auth contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn user_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/users/mod.rs");
|
|
for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"users facade should not own contracts or driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts = read_workspace_file("crates/aether-data/contracts/src/repository/users.rs");
|
|
for required in [
|
|
"pub struct StoredUserAuthRecord",
|
|
"pub struct StoredUserGroup",
|
|
"pub struct StoredUserSessionRecord",
|
|
"pub trait UserReadRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"user contracts should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool"] {
|
|
assert!(
|
|
!contracts.contains(forbidden),
|
|
"user contracts should remain infrastructure-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in
|
|
[("postgres", "aether_data_postgres", "SqlxUserReadRepository")]
|
|
{
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/users.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl UserReadRepository for {repository}"),
|
|
"users".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/users.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/users/{feature}.rs"
|
|
)),
|
|
"user SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists("crates/aether-data/runtime/src/repository/users/types.rs"),
|
|
"user contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn provider_catalog_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/provider_catalog/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"provider catalog facade should not own driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts = read_workspace_file(
|
|
"crates/aether-data/contracts/src/repository/provider_catalog/types.rs",
|
|
);
|
|
for required in [
|
|
"pub struct StoredProviderCatalogProvider",
|
|
"pub struct StoredProviderCatalogKey",
|
|
"pub trait ProviderCatalogReadRepository",
|
|
"pub trait ProviderCatalogWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"provider catalog contracts should own {required}"
|
|
);
|
|
}
|
|
let snapshot = read_workspace_file(
|
|
"crates/aether-data/contracts/src/repository/provider_catalog/snapshot.rs",
|
|
);
|
|
for required in [
|
|
"pub struct ProviderCatalogSnapshot",
|
|
"pub fn list_providers",
|
|
"pub fn list_keys_page",
|
|
] {
|
|
assert!(
|
|
snapshot.contains(required),
|
|
"provider catalog snapshot policy should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool", "RwLock"] {
|
|
assert!(
|
|
!snapshot.contains(forbidden),
|
|
"provider catalog snapshot should remain infrastructure-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxProviderCatalogReadRepository",
|
|
)] {
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/provider_catalog.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl ProviderCatalogReadRepository for {repository}"),
|
|
format!("impl ProviderCatalogWriteRepository for {repository}"),
|
|
"provider_api_keys".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/provider_catalog.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/provider_catalog/{feature}.rs"
|
|
)),
|
|
"provider catalog SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn wallet_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/wallet/mod.rs");
|
|
for forbidden in ["mod postgres;", "mod types;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"wallet facade should not own contracts or driver code via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/wallet/types.rs");
|
|
for required in [
|
|
"pub struct StoredWalletSnapshot",
|
|
"pub struct StoredAdminPaymentOrder",
|
|
"pub trait WalletReadRepository",
|
|
"pub trait WalletWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"wallet contracts should own {required}"
|
|
);
|
|
}
|
|
let snapshot =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/wallet/snapshot.rs");
|
|
for required in [
|
|
"pub struct WalletReadSeed",
|
|
"pub struct WalletReadSnapshot",
|
|
"pub fn list_admin_wallets",
|
|
] {
|
|
assert!(
|
|
snapshot.contains(required),
|
|
"wallet snapshot policy should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool", "RwLock"] {
|
|
assert!(
|
|
!snapshot.contains(forbidden),
|
|
"wallet snapshot should remain infrastructure-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
for (feature, adapter, repository) in
|
|
[("postgres", "aether_data_postgres", "SqlxWalletRepository")]
|
|
{
|
|
assert!(facade.contains(adapter) && facade.contains(repository));
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/wallet.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl WalletReadRepository for {repository}"),
|
|
format!("impl WalletWriteRepository for {repository}"),
|
|
"wallets".to_string(),
|
|
"sqlx::".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/wallet.rs should own {required}"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists(&format!(
|
|
"crates/aether-data/runtime/src/repository/wallet/{feature}.rs"
|
|
)),
|
|
"wallet SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
assert!(
|
|
!workspace_file_exists("crates/aether-data/runtime/src/repository/wallet/types.rs"),
|
|
"wallet contracts must not be duplicated in aether-data"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn usage_repositories_are_owned_by_contracts_and_driver_adapters() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/usage/mod.rs");
|
|
for forbidden in [
|
|
"mod postgres;",
|
|
"sqlx::",
|
|
"QueryBuilder",
|
|
"pub(crate) struct ApiKeyUsageDelta",
|
|
"pub(crate) struct ProviderApiKeyUsageDelta",
|
|
] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"usage facade should not own driver or pure policy code via {forbidden}"
|
|
);
|
|
}
|
|
let contracts =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/usage/types.rs");
|
|
for required in [
|
|
"pub struct StoredRequestUsageAudit",
|
|
"pub struct UpsertUsageRecord",
|
|
"pub trait UsageReadRepository",
|
|
"pub trait UsageWriteRepository",
|
|
] {
|
|
assert!(
|
|
contracts.contains(required),
|
|
"usage contracts should own {required}"
|
|
);
|
|
}
|
|
let policy = read_workspace_file("crates/aether-data/contracts/src/repository/usage/policy.rs");
|
|
for required in [
|
|
"pub struct ApiKeyUsageDelta",
|
|
"pub struct ProviderApiKeyUsageDelta",
|
|
"pub fn usage_can_recover_terminal_failure",
|
|
"pub fn strip_deprecated_usage_display_fields",
|
|
] {
|
|
assert!(
|
|
policy.contains(required),
|
|
"usage policy should own {required}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool", "RwLock"] {
|
|
assert!(
|
|
!policy.contains(forbidden),
|
|
"usage policy should remain infrastructure-independent from {forbidden}"
|
|
);
|
|
}
|
|
|
|
let postgres = read_workspace_file("crates/aether-data/adapters/postgres/src/usage/mod.rs");
|
|
for required in [
|
|
"pub struct SqlxUsageReadRepository",
|
|
"impl UsageReadRepository for SqlxUsageReadRepository",
|
|
"impl UsageWriteRepository for SqlxUsageReadRepository",
|
|
"sqlx::",
|
|
] {
|
|
assert!(
|
|
postgres.contains(required),
|
|
"PostgreSQL usage adapter should own {required}"
|
|
);
|
|
}
|
|
|
|
for path in [
|
|
"crates/aether-data/runtime/src/repository/usage/postgres/mod.rs",
|
|
"crates/aether-data/runtime/src/repository/usage/postgres/cleanup.rs",
|
|
] {
|
|
assert!(
|
|
!workspace_file_exists(path),
|
|
"usage SQL must move out of {path}"
|
|
);
|
|
}
|
|
assert_eq!(
|
|
workspace_files_with_extension(
|
|
"crates/aether-data/adapters/postgres/src/usage/queries",
|
|
"sql"
|
|
)
|
|
.len(),
|
|
27,
|
|
"all PostgreSQL usage SQL fragments should be owned by the adapter crate"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn lifecycle_backfills_are_partitioned_by_driver() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/lifecycle/backfill.rs");
|
|
for module in ["mod postgres;", "mod types;", "mod tests;"] {
|
|
assert!(
|
|
facade.contains(module),
|
|
"backfill facade should declare {module}"
|
|
);
|
|
}
|
|
for forbidden in ["sqlx::", "PgPool", "BACKFILL_MIGRATOR", "CREATE TABLE"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"backfill facade should not own driver operations via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let types = read_workspace_file("crates/aether-data/runtime/src/lifecycle/backfill/types.rs");
|
|
assert!(types.contains("pub struct PendingBackfillInfo"));
|
|
assert!(!types.contains("sqlx::"));
|
|
|
|
let postgres =
|
|
read_workspace_file("crates/aether-data/runtime/src/lifecycle/backfill/postgres.rs");
|
|
for required in [
|
|
"sqlx::migrate!",
|
|
"pub async fn run_backfills",
|
|
"pub async fn pending_backfills",
|
|
"schema_backfills",
|
|
] {
|
|
assert!(
|
|
postgres.contains(required),
|
|
"backfill/postgres.rs should own {required}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn lifecycle_migrations_are_partitioned_by_driver() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/lifecycle/migrate.rs");
|
|
for module in ["mod postgres;", "mod types;", "mod tests;"] {
|
|
assert!(
|
|
facade.contains(module),
|
|
"migration facade should declare {module}"
|
|
);
|
|
}
|
|
for forbidden in [
|
|
"POSTGRES_MIGRATOR",
|
|
"PgConnection",
|
|
"PgPool",
|
|
"apply_snapshot_if_empty",
|
|
"sqlx::migrate!",
|
|
] {
|
|
assert!(
|
|
!production_source(&facade).contains(forbidden),
|
|
"migration facade should not own PostgreSQL execution via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let types = read_workspace_file("crates/aether-data/runtime/src/lifecycle/migrate/types.rs");
|
|
let required = "pub use aether_data_contracts::PendingMigrationInfo";
|
|
assert!(
|
|
types.contains(required),
|
|
"migrate/types.rs should own {required}"
|
|
);
|
|
let forbidden = "PgPool";
|
|
assert!(
|
|
!types.contains(forbidden),
|
|
"migrate/types.rs should remain driver-independent from {forbidden}"
|
|
);
|
|
|
|
let postgres =
|
|
read_workspace_file("crates/aether-data/runtime/src/lifecycle/migrate/postgres.rs");
|
|
assert!(postgres.contains("aether_data_postgres"));
|
|
assert!(postgres.contains("PgPool"));
|
|
assert!(postgres.contains("pub async fn run_migrations"));
|
|
assert!(postgres.contains("apply_snapshot_if_empty"));
|
|
assert!(postgres.contains("pub async fn prepare_database_for_startup"));
|
|
assert!(!postgres.contains("sqlx::migrate!"));
|
|
let postgres_adapter =
|
|
read_workspace_file("crates/aether-data/adapters/postgres/src/migrations.rs");
|
|
assert!(postgres_adapter.contains("sqlx::migrate!(\"./migrations\")"));
|
|
assert!(workspace_file_exists(
|
|
"crates/aether-data/adapters/postgres/migrations/20260403000000_baseline.sql"
|
|
));
|
|
for required in [
|
|
"sqlx::migrate!",
|
|
"PgPool",
|
|
"pub async fn run_migrations",
|
|
"pub async fn pending_migrations",
|
|
"pub async fn run_migrations_with_bootstrap",
|
|
"pub trait PostgresMigrationBootstrap",
|
|
] {
|
|
assert!(
|
|
postgres_adapter.contains(required),
|
|
"crates/aether-data/adapters/postgres/src/migrations.rs should own {required}"
|
|
);
|
|
}
|
|
|
|
assert!(
|
|
!workspace_file_exists("crates/aether-data/runtime/migrations"),
|
|
"driver migration SQL must be owned by adapter crates"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn routing_profile_repositories_are_owned_by_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/routing_profiles/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"routing profile facade should not own driver implementation via {forbidden}"
|
|
);
|
|
}
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"PostgresRoutingGroupRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
|
|
"routing profile facade should preserve the {feature} feature boundary"
|
|
);
|
|
assert!(
|
|
facade.contains(&format!("pub use {adapter}::{repository};")),
|
|
"routing profile facade should re-export {repository} from {adapter}"
|
|
);
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/routing_profiles.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl RoutingGroupReadRepository for {repository}"),
|
|
format!("impl RoutingGroupWriteRepository for {repository}"),
|
|
"sqlx::query".to_string(),
|
|
"FROM routing_groups".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/routing_profiles.rs should own {required}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn provider_quota_repositories_are_owned_by_driver_adapters() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/repository/quota/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "SelectQuery"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"provider quota facade should not own driver implementation via {forbidden}"
|
|
);
|
|
}
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxProviderQuotaRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
|
|
"provider quota facade should preserve the {feature} feature boundary"
|
|
);
|
|
assert!(
|
|
facade.contains(&format!("pub use {adapter}::{repository};")),
|
|
"provider quota facade should re-export {repository} from {adapter}"
|
|
);
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/quota.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl ProviderQuotaReadRepository for {repository}"),
|
|
format!("impl ProviderQuotaWriteRepository for {repository}"),
|
|
"sqlx::query".to_string(),
|
|
"UPDATE providers".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/quota.rs should own {required}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pool_score_repositories_are_owned_by_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/pool_scores/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"pool score facade should not own driver implementation via {forbidden}"
|
|
);
|
|
}
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"PostgresPoolMemberScoreRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
|
|
"pool score facade should preserve the {feature} feature boundary"
|
|
);
|
|
assert!(
|
|
facade.contains(&format!("pub use {adapter}::{repository};")),
|
|
"pool score facade should re-export {repository} from {adapter}"
|
|
);
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/pool_scores.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl PoolScoreReadRepository for {repository}"),
|
|
format!("impl PoolMemberScoreWriteRepository for {repository}"),
|
|
"sqlx::query".to_string(),
|
|
"pool_member_scores".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/pool_scores.rs should own {required}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn background_task_repositories_are_owned_by_driver_adapters() {
|
|
let facade =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/background_tasks/mod.rs");
|
|
for forbidden in ["mod postgres;", "sqlx::", "QueryBuilder"] {
|
|
assert!(
|
|
!facade.contains(forbidden),
|
|
"background task facade should not own driver implementation via {forbidden}"
|
|
);
|
|
}
|
|
for (feature, adapter, repository) in [(
|
|
"postgres",
|
|
"aether_data_postgres",
|
|
"SqlxBackgroundTaskRepository",
|
|
)] {
|
|
assert!(
|
|
facade.contains(&format!("#[cfg(feature = \"{feature}\")]")),
|
|
"background task facade should preserve the {feature} feature boundary"
|
|
);
|
|
assert!(
|
|
facade.contains(&format!("pub use {adapter}::{repository};")),
|
|
"background task facade should re-export {repository} from {adapter}"
|
|
);
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/adapters/{feature}/src/background_tasks.rs"
|
|
));
|
|
for required in [
|
|
format!("pub struct {repository}"),
|
|
format!("impl BackgroundTaskReadRepository for {repository}"),
|
|
format!("impl BackgroundTaskWriteRepository for {repository}"),
|
|
"sqlx::query".to_string(),
|
|
"background_task_runs".to_string(),
|
|
"background_task_events".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"aether-data-{feature}/src/background_tasks.rs should own {required}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn lifecycle_driver_export_operations_are_partitioned() {
|
|
let facade = read_workspace_file("crates/aether-data/runtime/src/lifecycle/export.rs");
|
|
for required in ["mod postgres;", "mod tests;"] {
|
|
assert!(
|
|
facade.contains(required),
|
|
"export facade should declare {required}"
|
|
);
|
|
}
|
|
assert!(!facade.contains("mod tests {"));
|
|
|
|
for (driver, implementation_marker) in [("postgres", "fn normalize_postgres_import_payload(")] {
|
|
for required in [
|
|
format!("pub use {driver}::"),
|
|
format!("export_{driver}_core_jsonl"),
|
|
format!("import_{driver}_plan"),
|
|
] {
|
|
assert!(
|
|
facade.contains(&required),
|
|
"export facade should expose {driver} via {required}"
|
|
);
|
|
}
|
|
for forbidden in [
|
|
format!("pub async fn export_{driver}_core_jsonl("),
|
|
format!("pub async fn export_{driver}_jsonl("),
|
|
format!("pub async fn import_{driver}_jsonl("),
|
|
format!("pub async fn import_{driver}_plan("),
|
|
format!("fn {driver}_domain_table("),
|
|
implementation_marker.to_string(),
|
|
] {
|
|
assert!(
|
|
!facade.contains(&forbidden),
|
|
"export facade should not own {driver} implementation via {forbidden}"
|
|
);
|
|
}
|
|
|
|
let source = read_workspace_file(&format!(
|
|
"crates/aether-data/runtime/src/lifecycle/export/{driver}.rs"
|
|
));
|
|
for required in [
|
|
format!("pub async fn export_{driver}_core_jsonl("),
|
|
format!("pub async fn export_{driver}_jsonl("),
|
|
format!("pub async fn import_{driver}_jsonl("),
|
|
format!("pub async fn import_{driver}_plan("),
|
|
format!("fn {driver}_domain_table("),
|
|
implementation_marker.to_string(),
|
|
"sqlx::query".to_string(),
|
|
] {
|
|
assert!(
|
|
source.contains(&required),
|
|
"export/{driver}.rs should own {required}"
|
|
);
|
|
}
|
|
}
|
|
|
|
let tests = read_workspace_file("crates/aether-data/runtime/src/lifecycle/export/tests.rs");
|
|
assert!(tests.contains("jsonl_round_trips_manifest_and_domain_rows"));
|
|
assert!(tests.contains("postgres_import_payload_normalizes_imported_values_for_target_columns"));
|
|
}
|
|
|
|
#[test]
|
|
fn testkit_does_not_copy_aether_business_schema_sql() {
|
|
let owner_relay_baseline = read_workspace_file(
|
|
"crates/aether-testing/integration/src/bin/multi_instance_owner_relay_baseline.rs",
|
|
);
|
|
for forbidden in [
|
|
"CREATE TYPE proxynodestatus",
|
|
"CREATE TABLE IF NOT EXISTS system_configs",
|
|
"CREATE TABLE IF NOT EXISTS proxy_nodes",
|
|
"CREATE TABLE IF NOT EXISTS proxy_node_events",
|
|
"PgConnection::connect",
|
|
"sqlx::{Connection, Executor, PgConnection}",
|
|
] {
|
|
assert!(
|
|
!owner_relay_baseline.contains(forbidden),
|
|
"owner relay baseline should use aether-data schema bootstrap instead of copying business schema SQL via {forbidden}"
|
|
);
|
|
}
|
|
assert!(
|
|
owner_relay_baseline.contains("prepare_aether_postgres_schema(&postgres_url).await?"),
|
|
"owner relay baseline should prepare business schema through aether-testkit's aether-data helper"
|
|
);
|
|
|
|
let postgres_testkit = read_workspace_file("crates/aether-testing/testkit/src/postgres.rs");
|
|
for required in [
|
|
"pub async fn prepare_aether_postgres_schema",
|
|
"DataBackends::from_config",
|
|
".prepare_database_for_startup()",
|
|
".run_database_migrations()",
|
|
] {
|
|
assert!(
|
|
postgres_testkit.contains(required),
|
|
"shared Postgres helper should delegate Aether schema setup to aether-data via {required}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gateway_main_keeps_database_export_import_driver_selection_in_data_layer() {
|
|
let main_rs = read_workspace_file("apps/aether-gateway/src/main.rs");
|
|
for forbidden in ["PostgresPoolFactory", "to_postgres_config()"] {
|
|
assert!(
|
|
!main_rs.contains(forbidden),
|
|
"main.rs should delegate database export/import driver selection to aether-data instead of {forbidden}"
|
|
);
|
|
}
|
|
for required in ["export_database_jsonl", "import_database_jsonl"] {
|
|
assert!(
|
|
main_rs.contains(required),
|
|
"main.rs should use aether-data {required}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn wallet_repository_does_not_reexport_settlement_types() {
|
|
let wallet_mod = read_workspace_file("crates/aether-data/runtime/src/repository/wallet/mod.rs");
|
|
let wallet_types =
|
|
read_workspace_file("crates/aether-data/contracts/src/repository/wallet/types.rs");
|
|
let wallet_sql = read_workspace_file("crates/aether-data/adapters/postgres/src/wallet.rs");
|
|
let wallet_memory =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/wallet/memory.rs");
|
|
|
|
assert!(
|
|
!wallet_mod.contains("StoredUsageSettlement"),
|
|
"wallet/mod.rs should not export StoredUsageSettlement"
|
|
);
|
|
assert!(
|
|
!wallet_mod.contains("UsageSettlementInput"),
|
|
"wallet/mod.rs should not export UsageSettlementInput"
|
|
);
|
|
assert!(
|
|
!wallet_types.contains("pub use crate::repository::settlement"),
|
|
"wallet/types.rs should not re-export settlement types"
|
|
);
|
|
assert!(
|
|
!wallet_types.contains("async fn settle_usage("),
|
|
"wallet/types.rs should not own settlement entrypoints"
|
|
);
|
|
assert!(
|
|
!wallet_sql.contains("impl SettlementWriteRepository"),
|
|
"wallet/postgres.rs should not implement SettlementWriteRepository"
|
|
);
|
|
assert!(
|
|
!wallet_memory.contains("impl SettlementWriteRepository"),
|
|
"wallet/memory.rs should not implement SettlementWriteRepository"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gateway_system_config_types_are_owned_by_aether_data() {
|
|
let state_mod = read_workspace_file("apps/aether-gateway/src/data/state/mod.rs");
|
|
assert!(
|
|
state_mod.contains("aether_data::repository::system"),
|
|
"data/state/mod.rs should depend on aether-data system types"
|
|
);
|
|
assert!(
|
|
!state_mod.contains("pub(crate) struct StoredSystemConfigEntry"),
|
|
"data/state/mod.rs should not define StoredSystemConfigEntry locally"
|
|
);
|
|
|
|
let state_core = read_workspace_file("apps/aether-gateway/src/data/state/core.rs");
|
|
for pattern in [
|
|
"backends.list_system_config_entries().await",
|
|
".upsert_system_config_entry(key, value, description)",
|
|
"backends.read_admin_system_stats().await",
|
|
"AdminSystemStats::default()",
|
|
] {
|
|
assert!(
|
|
state_core.contains(pattern),
|
|
"data/state/core.rs should use shared system DTO path {pattern}"
|
|
);
|
|
}
|
|
let data_backends =
|
|
read_workspace_file("crates/aether-data/runtime/src/backend/maintenance.rs");
|
|
let pattern = "postgres.list_system_config_entries().await";
|
|
assert!(
|
|
data_backends.contains(pattern),
|
|
"aether-data backends should own driver-specific system config dispatch {pattern}"
|
|
);
|
|
for pattern in [
|
|
"|(key, value, description, updated_at_unix_secs)|",
|
|
"Ok((0, 0, 0, 0))",
|
|
] {
|
|
assert!(
|
|
!state_core.contains(pattern),
|
|
"data/state/core.rs should not own local system DTO projection {pattern}"
|
|
);
|
|
}
|
|
|
|
let system_types = read_workspace_file("crates/aether-data/runtime/src/repository/system.rs");
|
|
for pattern in [
|
|
"pub struct StoredSystemConfigEntry",
|
|
"pub struct AdminSystemStats",
|
|
"pub struct AdminSecurityBlacklistEntry",
|
|
] {
|
|
assert!(
|
|
system_types.contains(pattern),
|
|
"aether-data system module should own {pattern}"
|
|
);
|
|
}
|
|
|
|
let admin_types = read_workspace_file("apps/aether-gateway/src/state/admin_types.rs");
|
|
assert!(
|
|
admin_types.contains("aether_data::repository::system::AdminSecurityBlacklistEntry"),
|
|
"state/admin_types.rs should re-export AdminSecurityBlacklistEntry from aether-data"
|
|
);
|
|
assert!(
|
|
!admin_types.contains("struct AdminSecurityBlacklistEntry"),
|
|
"state/admin_types.rs should not define AdminSecurityBlacklistEntry locally"
|
|
);
|
|
|
|
let runtime_mod = read_workspace_file("apps/aether-gateway/src/state/runtime/mod.rs");
|
|
assert!(
|
|
!runtime_mod.contains("AdminSecurityBlacklistEntryPayload"),
|
|
"state/runtime/mod.rs should not keep the unused blacklist payload wrapper"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gateway_auth_snapshot_type_is_owned_by_aether_data() {
|
|
let gateway_auth = read_workspace_file("apps/aether-gateway/src/data/auth.rs");
|
|
let runtime_mod = read_workspace_file("apps/aether-gateway/src/state/runtime/mod.rs");
|
|
let auth_api_keys =
|
|
read_workspace_file("apps/aether-gateway/src/state/runtime/auth/api_keys.rs");
|
|
assert!(
|
|
gateway_auth.contains("aether_data::repository::auth"),
|
|
"data/auth.rs should depend on aether-data auth snapshot types"
|
|
);
|
|
assert!(
|
|
gateway_auth.contains("ResolvedAuthApiKeySnapshot as GatewayAuthApiKeySnapshot"),
|
|
"data/auth.rs should expose the shared resolved auth snapshot type under the gateway-facing name"
|
|
);
|
|
for pattern in [
|
|
"pub(crate) struct GatewayAuthApiKeySnapshot",
|
|
"pub(crate) async fn read_auth_api_key_snapshot(",
|
|
"pub(crate) async fn read_auth_api_key_snapshot_by_key_hash(",
|
|
"fn effective_allowed_providers(",
|
|
"fn effective_allowed_api_formats(",
|
|
"fn effective_allowed_models(",
|
|
] {
|
|
assert!(
|
|
!gateway_auth.contains(pattern),
|
|
"data/auth.rs should not own local auth snapshot logic {pattern}"
|
|
);
|
|
}
|
|
for pattern in [
|
|
"pub(crate) async fn read_auth_api_key_snapshot(",
|
|
"pub(crate) async fn read_auth_api_key_snapshots_by_ids(",
|
|
] {
|
|
assert!(
|
|
!auth_api_keys.contains(pattern),
|
|
"state/runtime/auth/api_keys.rs should not keep auth snapshot read wrapper {pattern}"
|
|
);
|
|
}
|
|
assert!(
|
|
!runtime_mod.contains("mod audit;"),
|
|
"state/runtime/mod.rs should not keep the obsolete audit runtime module"
|
|
);
|
|
assert!(
|
|
auth_api_keys.contains("touch_auth_api_key_last_used_best_effort"),
|
|
"state/runtime/auth/api_keys.rs should own auth api key last_used touch helper"
|
|
);
|
|
assert!(
|
|
!auth_api_keys.contains("fn has_auth_api_key_writer("),
|
|
"state/runtime/auth/api_keys.rs should not keep auth api key writer passthrough"
|
|
);
|
|
|
|
let auth_types = read_workspace_file("crates/aether-data/contracts/src/repository/auth.rs");
|
|
for pattern in [
|
|
"pub struct ResolvedAuthApiKeySnapshot",
|
|
"pub trait ResolvedAuthApiKeySnapshotReader",
|
|
"pub async fn read_resolved_auth_api_key_snapshot(",
|
|
"pub async fn read_resolved_auth_api_key_snapshot_by_key_hash(",
|
|
"pub async fn read_resolved_auth_api_key_snapshot_by_user_api_key_ids(",
|
|
"pub fn effective_allowed_providers(&self)",
|
|
"pub fn effective_allowed_api_formats(&self)",
|
|
"pub fn effective_allowed_models(&self)",
|
|
] {
|
|
assert!(
|
|
auth_types.contains(pattern),
|
|
"aether-data auth types should own {pattern}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gateway_auth_data_layer_does_not_keep_ldap_row_wrapper() {
|
|
let gateway_auth_state = read_workspace_file("apps/aether-gateway/src/data/state/auth.rs");
|
|
for pattern in [
|
|
"struct StoredLdapAuthUserRow",
|
|
"fn map_ldap_user_auth_row(",
|
|
"Result<Option<StoredLdapAuthUserRow>, DataLayerError>",
|
|
"existing.user.",
|
|
"map_user_auth_row(row)",
|
|
] {
|
|
assert!(
|
|
!gateway_auth_state.contains(pattern),
|
|
"data/state/auth.rs should not keep ldap row wrapper {pattern}"
|
|
);
|
|
}
|
|
|
|
let user_sql = read_workspace_file("crates/aether-data/adapters/postgres/src/users.rs");
|
|
for pattern in [
|
|
"Result<Option<StoredUserAuthRecord>, DataLayerError>",
|
|
"return map_user_auth_row(row).map(Some);",
|
|
] {
|
|
assert!(
|
|
user_sql.contains(pattern),
|
|
"aether-data user repository should use shared user auth record directly via {pattern}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn gateway_provider_oauth_storage_types_are_owned_by_aether_data() {
|
|
let provider_oauth_storage = read_workspace_file(
|
|
"apps/aether-gateway/src/handlers/admin/provider/oauth/state/storage.rs",
|
|
);
|
|
let request_provider_oauth =
|
|
read_workspace_file("apps/aether-gateway/src/handlers/admin/request/provider/oauth.rs");
|
|
assert!(
|
|
request_provider_oauth.contains("aether_data::repository::provider_oauth"),
|
|
"request/provider/oauth.rs should depend on aether-data provider oauth storage types"
|
|
);
|
|
for pattern in [
|
|
"pub(crate) struct StoredAdminProviderOAuthDeviceSession",
|
|
"pub(crate) struct StoredAdminProviderOAuthState",
|
|
"const KIRO_DEVICE_AUTH_SESSION_PREFIX",
|
|
"fn provider_oauth_device_session_key(",
|
|
"fn build_provider_oauth_batch_task_status_payload(",
|
|
"fn provider_oauth_batch_task_key(",
|
|
"const PROVIDER_OAUTH_BATCH_TASK_TTL_SECS",
|
|
"format!(\"provider_oauth_state:{nonce}\")",
|
|
] {
|
|
assert!(
|
|
!provider_oauth_storage.contains(pattern),
|
|
"provider_oauth/state/storage.rs should not own local storage helper {pattern}"
|
|
);
|
|
}
|
|
for pattern in [
|
|
"StoredAdminProviderOAuthDeviceSession",
|
|
"StoredAdminProviderOAuthState",
|
|
"provider_oauth_batch_task_storage_key",
|
|
"build_provider_oauth_batch_task_status_payload",
|
|
"PROVIDER_OAUTH_BATCH_TASK_TTL_SECS",
|
|
] {
|
|
assert!(
|
|
request_provider_oauth.contains(pattern),
|
|
"request/provider/oauth.rs should own aether-data provider oauth storage boundary {pattern}"
|
|
);
|
|
}
|
|
|
|
assert!(
|
|
!workspace_file_exists("apps/aether-gateway/src/handlers/admin/provider/oauth/state.rs"),
|
|
"provider_oauth/state.rs should not exist after oauth storage helpers move under state/storage.rs"
|
|
);
|
|
|
|
let dispatch_device_authorize = read_workspace_file(
|
|
"apps/aether-gateway/src/handlers/admin/provider/oauth/dispatch/device/authorize.rs",
|
|
);
|
|
assert!(
|
|
dispatch_device_authorize.contains("aether_data::repository::provider_oauth"),
|
|
"provider_oauth/dispatch/device/authorize.rs should use shared provider oauth storage DTOs"
|
|
);
|
|
assert!(
|
|
!workspace_file_exists(
|
|
"apps/aether-gateway/src/handlers/admin/provider/oauth/dispatch/device.rs"
|
|
),
|
|
"provider_oauth/dispatch/device.rs should be removed once device flows move under dispatch/device/"
|
|
);
|
|
|
|
let shared_provider_oauth =
|
|
read_workspace_file("crates/aether-data/runtime/src/repository/provider_oauth.rs");
|
|
for pattern in [
|
|
"pub struct StoredAdminProviderOAuthDeviceSession",
|
|
"pub struct StoredAdminProviderOAuthState",
|
|
"pub fn provider_oauth_device_session_storage_key(",
|
|
"pub fn provider_oauth_state_storage_key(",
|
|
"pub fn provider_oauth_batch_task_storage_key(",
|
|
"pub fn build_provider_oauth_batch_task_status_payload(",
|
|
"pub const KIRO_DEVICE_AUTH_SESSION_TTL_BUFFER_SECS: u64 = 60;",
|
|
"pub const PROVIDER_OAUTH_BATCH_TASK_TTL_SECS: u64 = 24 * 60 * 60;",
|
|
"pub const PROVIDER_OAUTH_STATE_TTL_SECS: u64 = 600;",
|
|
] {
|
|
assert!(
|
|
shared_provider_oauth.contains(pattern),
|
|
"aether-data provider oauth storage module should own {pattern}"
|
|
);
|
|
}
|
|
}
|