style: cargo fmt all new and modified files

Author: parv68

crates/aegis-core/benches/explain.rs

@@ -1,8 +1,8 @@
 use criterion::{Criterion, black_box, criterion_group, criterion_main};
 
 use aegis_core::engine::GraphEngine;
-use aegis_core::storage::sqlite::{SqliteConfig, SqliteStorage};
 use aegis_core::storage::StorageBackend;
+use aegis_core::storage::sqlite::{SqliteConfig, SqliteStorage};
 use aegis_core::types::schema::{PermissionDef, RelationDef, Schema, TypeDef};
 use aegis_core::types::*;
 use std::collections::HashMap;

crates/aegis-core/benches/memory.rs

@@ -1,8 +1,8 @@
 use criterion::{Criterion, black_box, criterion_group, criterion_main};
 
 use aegis_core::engine::GraphEngine;
-use aegis_core::storage::sqlite::{SqliteConfig, SqliteStorage};
 use aegis_core::storage::StorageBackend;
+use aegis_core::storage::sqlite::{SqliteConfig, SqliteStorage};
 use aegis_core::types::schema::{PermissionDef, RelationDef, Schema, TypeDef};
 use aegis_core::types::*;
 use std::collections::HashMap;
@@ -12,13 +12,7 @@ fn current_rss_kb() -> u64 {
     {
         let pid = std::process::id();
         let output = std::process::Command::new("tasklist")
-            .args([
-                "/FI",
-                &format!("PID eq {}", pid),
-                "/FO",
-                "CSV",
-                "/NH",
-            ])
+            .args(["/FI", &format!("PID eq {}", pid), "/FO", "CSV", "/NH"])
             .output()
             .expect("tasklist failed");
         let stdout = String::from_utf8(output.stdout).expect("invalid utf8");

crates/aegis-core/benches/write.rs

@@ -1,8 +1,8 @@
 use criterion::{Criterion, black_box, criterion_group, criterion_main};
 
 use aegis_core::engine::GraphEngine;
-use aegis_core::storage::sqlite::{SqliteConfig, SqliteStorage};
 use aegis_core::storage::StorageBackend;
+use aegis_core::storage::sqlite::{SqliteConfig, SqliteStorage};
 use aegis_core::types::schema::{PermissionDef, RelationDef, Schema, TypeDef};
 use aegis_core::types::*;
 use std::collections::HashMap;

crates/aegis-core/src/engine/cache.rs

@@ -399,8 +399,22 @@ mod tests {
     #[test]
     fn test_cache_invalidate_before() {
         let mut cache = DecisionCache::new(100);
-        cache.insert("user:1", "read", "repo:a", "default", true, Revision::new(5));
-        cache.insert("user:2", "read", "repo:b", "default", true, Revision::new(10));
+        cache.insert(
+            "user:1",
+            "read",
+            "repo:a",
+            "default",
+            true,
+            Revision::new(5),
+        );
+        cache.insert(
+            "user:2",
+            "read",
+            "repo:b",
+            "default",
+            true,
+            Revision::new(10),
+        );
 
         cache.invalidate_before(Revision::new(8));
 
@@ -426,10 +440,7 @@ mod tests {
             Revision::new(5),
         );
         cache.clear();
-        assert_eq!(
-            cache.get("user:1", "owner", Revision::new(5)),
-            None
-        );
+        assert_eq!(cache.get("user:1", "owner", Revision::new(5)), None);
     }
 
     #[test]
@@ -450,10 +461,7 @@ mod tests {
 
         cache.invalidate_before(Revision::new(8));
 
-        assert_eq!(
-            cache.get("user:1", "owner", Revision::new(5)),
-            None
-        );
+        assert_eq!(cache.get("user:1", "owner", Revision::new(5)), None);
         assert_eq!(
             cache.get("user:2", "owner", Revision::new(10)),
             Some(vec!["repo:b".to_string()])

crates/aegis-core/src/engine/watch.rs

@@ -547,12 +547,10 @@ mod tests {
         assert!(last_rev.as_u64() > 5, "need revision > 5 for test setup");
 
         // Now subscribe with since_revision=5
-        let since_sub = engine.watch(
-            WatchFilter {
-                since_revision: Some(Revision::new(5)),
-                ..Default::default()
-            },
-        );
+        let since_sub = engine.watch(WatchFilter {
+            since_revision: Some(Revision::new(5)),
+            ..Default::default()
+        });
 
         // Write another tuple — revision will be > 5
         let token = engine

crates/aegis-core/src/storage/sqlite.rs

@@ -3139,13 +3139,21 @@ mod tests {
     fn test_audit_entry_has_timestamp() {
         let mut store = storage();
         store.initialize().unwrap();
-        store.write_tuple(&PartitionId::default(), &tuple("user:ts", "owner", "repo:ts")).unwrap();
-        let entries = store.query_audit(
-            &PartitionId::default(),
-            Some(&ResourceId::new("repo:ts").unwrap()),
-            None, None,
-            &PaginationParams::default(),
-        ).unwrap();
+        store
+            .write_tuple(
+                &PartitionId::default(),
+                &tuple("user:ts", "owner", "repo:ts"),
+            )
+            .unwrap();
+        let entries = store
+            .query_audit(
+                &PartitionId::default(),
+                Some(&ResourceId::new("repo:ts").unwrap()),
+                None,
+                None,
+                &PaginationParams::default(),
+            )
+            .unwrap();
         assert_eq!(entries.len(), 1);
         assert!(entries[0].timestamp.timestamp() > 0);
     }

crates/aegis-core/tests/multitenancy.rs

@@ -86,18 +86,11 @@ fn test_tenant_isolation_write_read() {
         ))
         .unwrap();
 
-    let result = engine_a
-        .check(&subject, "read", &resource, None)
-        .unwrap();
+    let result = engine_a.check(&subject, "read", &resource, None).unwrap();
     assert!(result.allowed, "tenant_a should read its own tuple");
 
-    let result = engine_b
-        .check(&subject, "read", &resource, None)
-        .unwrap();
-    assert!(
-        !result.allowed,
-        "tenant_b should not read tenant_a's tuple"
-    );
+    let result = engine_b.check(&subject, "read", &resource, None).unwrap();
+    assert!(!result.allowed, "tenant_b should not read tenant_a's tuple");
 
     engine_a.close().unwrap();
     engine_b.close().unwrap();
@@ -188,17 +181,10 @@ fn test_tenant_admin_cannot_access_other_tenant() {
         ))
         .unwrap();
 
-    let result = engine_a
-        .check(&admin_a, "read", &resource_a, None)
-        .unwrap();
-    assert!(
-        result.allowed,
-        "admin_tenant_a should access tenant_a data"
-    );
+    let result = engine_a.check(&admin_a, "read", &resource_a, None).unwrap();
+    assert!(result.allowed, "admin_tenant_a should access tenant_a data");
 
-    let result = engine_b
-        .check(&admin_a, "read", &resource_b, None)
-        .unwrap();
+    let result = engine_b.check(&admin_a, "read", &resource_b, None).unwrap();
     assert!(
         !result.allowed,
         "admin_tenant_a should not access tenant_b data"
@@ -277,10 +263,7 @@ types:
     let result = engine
         .check(&super_admin, "read", &resource_a, None)
         .unwrap();
-    assert!(
-        result.allowed,
-        "super:admin should read tenant_a resource"
-    );
+    assert!(result.allowed, "super:admin should read tenant_a resource");
 
     let result = engine
         .check(&super_admin, "read", &resource_b, None)
@@ -354,11 +337,7 @@ types:
     let result = engine
         .query(&filter, &PaginationParams::new(100, None), None)
         .unwrap();
-    assert_eq!(
-        result.tuples.len(),
-        5,
-        "should get exactly 5 repo tuples"
-    );
+    assert_eq!(result.tuples.len(), 5, "should get exactly 5 repo tuples");
     for t in &result.tuples {
         assert!(
             t.object.as_str().starts_with("repo:"),
@@ -374,11 +353,7 @@ types:
     let result = engine
         .query(&filter, &PaginationParams::new(100, None), None)
         .unwrap();
-    assert_eq!(
-        result.tuples.len(),
-        5,
-        "should get exactly 5 doc tuples"
-    );
+    assert_eq!(result.tuples.len(), 5, "should get exactly 5 doc tuples");
     for t in &result.tuples {
         assert!(
             t.object.as_str().starts_with("doc:"),
@@ -403,8 +378,7 @@ fn test_concurrent_tenant_operations() {
         std::thread::spawn(move || {
             for i in 0..20 {
                 let subject = SubjectId::new(format!("user:a{}", i)).unwrap();
-                let resource =
-                    ResourceId::new(format!("tenant_a_repo:r{}", i)).unwrap();
+                let resource = ResourceId::new(format!("tenant_a_repo:r{}", i)).unwrap();
                 engine
                     .write(&RelationshipTuple::new(
                         subject,
@@ -421,8 +395,7 @@ fn test_concurrent_tenant_operations() {
         std::thread::spawn(move || {
             for i in 0..20 {
                 let subject = SubjectId::new(format!("user:b{}", i)).unwrap();
-                let resource =
-                    ResourceId::new(format!("tenant_b_repo:r{}", i)).unwrap();
+                let resource = ResourceId::new(format!("tenant_b_repo:r{}", i)).unwrap();
                 engine
                     .write(&RelationshipTuple::new(
                         subject,
@@ -444,11 +417,7 @@ fn test_concurrent_tenant_operations() {
             None,
         )
         .unwrap();
-    assert_eq!(
-        result.tuples.len(),
-        20,
-        "tenant_a should have 20 tuples"
-    );
+    assert_eq!(result.tuples.len(), 20, "tenant_a should have 20 tuples");
 
     let result = engine_b
         .query(
@@ -457,11 +426,7 @@ fn test_concurrent_tenant_operations() {
             None,
         )
         .unwrap();
-    assert_eq!(
-        result.tuples.len(),
-        20,
-        "tenant_b should have 20 tuples"
-    );
+    assert_eq!(result.tuples.len(), 20, "tenant_b should have 20 tuples");
 
     engine_a.close().unwrap();
     engine_b.close().unwrap();

crates/aegis-core/tests/persistence.rs

@@ -269,13 +269,19 @@ fn test_recover_from_events() {
 
     // Recover to the current revision (replays event log)
     let recovered = engine.recover_from_events(Some(rev)).unwrap();
-    assert!(recovered.as_u64() >= rev.as_u64(), "recovery should reach at least the current revision");
+    assert!(
+        recovered.as_u64() >= rev.as_u64(),
+        "recovery should reach at least the current revision"
+    );
 
     verify_n_tuples(&engine, 10);
 
     // Also test with None (recover to latest)
     let recovered = engine.recover_from_events(None).unwrap();
-    assert!(recovered.as_u64() >= rev.as_u64(), "recovery to latest should succeed");
+    assert!(
+        recovered.as_u64() >= rev.as_u64(),
+        "recovery to latest should succeed"
+    );
 
     verify_n_tuples(&engine, 10);
 

crates/aegis-core/tests/security.rs

@@ -85,11 +85,7 @@ fn test_subject_with_many_relationships() {
     let elapsed = start.elapsed();
 
     assert!(result.allowed);
-    assert!(
-        elapsed.as_secs() < 5,
-        "check took too long: {:?}",
-        elapsed
-    );
+    assert!(elapsed.as_secs() < 5, "check took too long: {:?}", elapsed);
 }
 
 #[test]

crates/aegis-core/tests/stress.rs

@@ -75,11 +75,13 @@ fn str005_read_pool_exhaustion() {
     let alice = SubjectId::new("user:alice").unwrap();
     let resource = ResourceId::new("repo:shared").unwrap();
 
-    engine.write(&RelationshipTuple::new(
-        alice.clone(),
-        Relation::new("owner").unwrap(),
-        resource.clone(),
-    )).unwrap();
+    engine
+        .write(&RelationshipTuple::new(
+            alice.clone(),
+            Relation::new("owner").unwrap(),
+            resource.clone(),
+        ))
+        .unwrap();
 
     let mut handles = vec![];
     for _ in 0..10 {
@@ -99,7 +101,9 @@ fn str005_read_pool_exhaustion() {
                 assert!(result.allowed);
                 ok_count += 1;
             }
-            Err(_) => { _err_count += 1; }
+            Err(_) => {
+                _err_count += 1;
+            }
         }
     }
 
@@ -474,17 +478,33 @@ fn str008_deep_hierarchy_scaled() {
 
     // Depth 5 from root should be reachable
     let result = engine
-        .check(&root, "read", &ResourceId::new("repo:level4").unwrap(), None)
+        .check(
+            &root,
+            "read",
+            &ResourceId::new("repo:level4").unwrap(),
+            None,
+        )
         .unwrap();
-    assert!(result.allowed, "root should have transitive access at depth 5");
+    assert!(
+        result.allowed,
+        "root should have transitive access at depth 5"
+    );
 
     // Depth 9 from root exceeds default max_traversal_depth (10)
     // The traversal starts at the resource being checked and walks up,
     // so depth 9 means 9 hops, which is within the limit of 10
     let result = engine
-        .check(&root, "read", &ResourceId::new("repo:level9").unwrap(), None)
+        .check(
+            &root,
+            "read",
+            &ResourceId::new("repo:level9").unwrap(),
+            None,
+        )
         .unwrap();
-    assert!(result.allowed, "root should have transitive access at depth 9");
+    assert!(
+        result.allowed,
+        "root should have transitive access at depth 9"
+    );
 
     engine.close().unwrap();
 }