diff --git a/crates/catalog/inmemory/src/catalog.rs b/crates/catalog/inmemory/src/catalog.rs
index eb2a545c6..1e7e77f4e 100644
--- a/crates/catalog/inmemory/src/catalog.rs
+++ b/crates/catalog/inmemory/src/catalog.rs
@@ -17,20 +17,19 @@
 
 //! This module contains memory catalog implementation.
 
-use futures::lock::Mutex;
-use iceberg::io::FileIO;
-use iceberg::spec::{TableMetadata, TableMetadataBuilder};
-use itertools::Itertools;
 use std::collections::HashMap;
-use uuid::Uuid;
 
 use async_trait::async_trait;
-
+use futures::lock::Mutex;
+use iceberg::io::FileIO;
+use iceberg::spec::{TableMetadata, TableMetadataBuilder};
 use iceberg::table::Table;
-use iceberg::Result;
 use iceberg::{
-    Catalog, Error, ErrorKind, Namespace, NamespaceIdent, TableCommit, TableCreation, TableIdent,
+    Catalog, Error, ErrorKind, Namespace, NamespaceIdent, Result, TableCommit, TableCreation,
+    TableIdent,
 };
+use itertools::Itertools;
+use uuid::Uuid;
 
 use crate::namespace_state::NamespaceState;
 
@@ -268,11 +267,12 @@ impl Catalog for MemoryCatalog {
 
 #[cfg(test)]
 mod tests {
-    use iceberg::io::FileIOBuilder;
-    use iceberg::spec::{NestedField, PartitionSpec, PrimitiveType, Schema, SortOrder, Type};
     use std::collections::HashSet;
     use std::hash::Hash;
     use std::iter::FromIterator;
+
+    use iceberg::io::FileIOBuilder;
+    use iceberg::spec::{NestedField, PartitionSpec, PrimitiveType, Schema, SortOrder, Type};
     use tempfile::TempDir;
 
     use super::*;
@@ -387,10 +387,9 @@ mod tests {
         let namespace_ident = NamespaceIdent::new("abc".into());
         create_namespace(&catalog, &namespace_ident).await;
 
-        assert_eq!(
-            catalog.list_namespaces(None).await.unwrap(),
-            vec![namespace_ident]
-        );
+        assert_eq!(catalog.list_namespaces(None).await.unwrap(), vec![
+            namespace_ident
+        ]);
     }
 
     #[tokio::test]
@@ -412,10 +411,11 @@ mod tests {
         let namespace_ident_1 = NamespaceIdent::new("a".into());
         let namespace_ident_2 = NamespaceIdent::from_strs(vec!["a", "b"]).unwrap();
         let namespace_ident_3 = NamespaceIdent::new("b".into());
-        create_namespaces(
-            &catalog,
-            &vec![&namespace_ident_1, &namespace_ident_2, &namespace_ident_3],
-        )
+        create_namespaces(&catalog, &vec![
+            &namespace_ident_1,
+            &namespace_ident_2,
+            &namespace_ident_3,
+        ])
         .await;
 
         assert_eq!(
@@ -446,10 +446,11 @@ mod tests {
         let namespace_ident_1 = NamespaceIdent::new("a".into());
         let namespace_ident_2 = NamespaceIdent::from_strs(vec!["a", "b"]).unwrap();
         let namespace_ident_3 = NamespaceIdent::new("c".into());
-        create_namespaces(
-            &catalog,
-            &vec![&namespace_ident_1, &namespace_ident_2, &namespace_ident_3],
-        )
+        create_namespaces(&catalog, &vec![
+            &namespace_ident_1,
+            &namespace_ident_2,
+            &namespace_ident_3,
+        ])
         .await;
 
         assert_eq!(
@@ -474,16 +475,13 @@ mod tests {
         let namespace_ident_3 = NamespaceIdent::from_strs(vec!["a", "b"]).unwrap();
         let namespace_ident_4 = NamespaceIdent::from_strs(vec!["a", "c"]).unwrap();
         let namespace_ident_5 = NamespaceIdent::new("b".into());
-        create_namespaces(
-            &catalog,
-            &vec![
-                &namespace_ident_1,
-                &namespace_ident_2,
-                &namespace_ident_3,
-                &namespace_ident_4,
-                &namespace_ident_5,
-            ],
-        )
+        create_namespaces(&catalog, &vec![
+            &namespace_ident_1,
+            &namespace_ident_2,
+            &namespace_ident_3,
+            &namespace_ident_4,
+            &namespace_ident_5,
+        ])
         .await;
 
         assert_eq!(
@@ -675,10 +673,9 @@ mod tests {
             )
         );
 
-        assert_eq!(
-            catalog.list_namespaces(None).await.unwrap(),
-            vec![namespace_ident_a.clone()]
-        );
+        assert_eq!(catalog.list_namespaces(None).await.unwrap(), vec![
+            namespace_ident_a.clone()
+        ]);
 
         assert_eq!(
             catalog
@@ -726,14 +723,11 @@ mod tests {
         let namespace_ident_a = NamespaceIdent::new("a".into());
         let namespace_ident_a_b = NamespaceIdent::from_strs(vec!["a", "b"]).unwrap();
         let namespace_ident_a_b_c = NamespaceIdent::from_strs(vec!["a", "b", "c"]).unwrap();
-        create_namespaces(
-            &catalog,
-            &vec![
-                &namespace_ident_a,
-                &namespace_ident_a_b,
-                &namespace_ident_a_b_c,
-            ],
-        )
+        create_namespaces(&catalog, &vec![
+            &namespace_ident_a,
+            &namespace_ident_a_b,
+            &namespace_ident_a_b_c,
+        ])
         .await;
 
         assert_eq!(
@@ -808,14 +802,11 @@ mod tests {
         let namespace_ident_a = NamespaceIdent::new("a".into());
         let namespace_ident_a_b = NamespaceIdent::from_strs(vec!["a", "b"]).unwrap();
         let namespace_ident_a_b_c = NamespaceIdent::from_strs(vec!["a", "b", "c"]).unwrap();
-        create_namespaces(
-            &catalog,
-            &vec![
-                &namespace_ident_a,
-                &namespace_ident_a_b,
-                &namespace_ident_a_b_c,
-            ],
-        )
+        create_namespaces(&catalog, &vec![
+            &namespace_ident_a,
+            &namespace_ident_a_b,
+            &namespace_ident_a_b_c,
+        ])
         .await;
 
         let mut new_properties = HashMap::new();
@@ -885,14 +876,11 @@ mod tests {
         let namespace_ident_a = NamespaceIdent::new("a".into());
         let namespace_ident_a_b = NamespaceIdent::from_strs(vec!["a", "b"]).unwrap();
         let namespace_ident_a_b_c = NamespaceIdent::from_strs(vec!["a", "b", "c"]).unwrap();
-        create_namespaces(
-            &catalog,
-            &vec![
-                &namespace_ident_a,
-                &namespace_ident_a_b,
-                &namespace_ident_a_b_c,
-            ],
-        )
+        create_namespaces(&catalog, &vec![
+            &namespace_ident_a,
+            &namespace_ident_a_b,
+            &namespace_ident_a_b_c,
+        ])
         .await;
 
         catalog
@@ -1061,10 +1049,9 @@ mod tests {
         let table_ident = TableIdent::new(namespace_ident.clone(), "tbl1".into());
         create_table(&catalog, &table_ident).await;
 
-        assert_eq!(
-            catalog.list_tables(&namespace_ident).await.unwrap(),
-            vec![table_ident]
-        );
+        assert_eq!(catalog.list_tables(&namespace_ident).await.unwrap(), vec![
+            table_ident
+        ]);
     }
 
     #[tokio::test]
@@ -1093,10 +1080,11 @@ mod tests {
         let table_ident_1 = TableIdent::new(namespace_ident_1.clone(), "tbl1".into());
         let table_ident_2 = TableIdent::new(namespace_ident_1.clone(), "tbl2".into());
         let table_ident_3 = TableIdent::new(namespace_ident_2.clone(), "tbl1".into());
-        let _ = create_tables(
-            &catalog,
-            vec![&table_ident_1, &table_ident_2, &table_ident_3],
-        )
+        let _ = create_tables(&catalog, vec![
+            &table_ident_1,
+            &table_ident_2,
+            &table_ident_3,
+        ])
         .await;
 
         assert_eq!(
@@ -1294,10 +1282,9 @@ mod tests {
             .await
             .unwrap();
 
-        assert_eq!(
-            catalog.list_tables(&namespace_ident).await.unwrap(),
-            vec![dst_table_ident],
-        );
+        assert_eq!(catalog.list_tables(&namespace_ident).await.unwrap(), vec![
+            dst_table_ident
+        ],);
     }
 
     #[tokio::test]
@@ -1339,10 +1326,9 @@ mod tests {
             .await
             .unwrap();
 
-        assert_eq!(
-            catalog.list_tables(&namespace_ident).await.unwrap(),
-            vec![table_ident],
-        );
+        assert_eq!(catalog.list_tables(&namespace_ident).await.unwrap(), vec![
+            table_ident
+        ],);
     }
 
     #[tokio::test]
@@ -1351,14 +1337,11 @@ mod tests {
         let namespace_ident_a = NamespaceIdent::new("a".into());
         let namespace_ident_a_b = NamespaceIdent::from_strs(vec!["a", "b"]).unwrap();
         let namespace_ident_a_b_c = NamespaceIdent::from_strs(vec!["a", "b", "c"]).unwrap();
-        create_namespaces(
-            &catalog,
-            &vec![
-                &namespace_ident_a,
-                &namespace_ident_a_b,
-                &namespace_ident_a_b_c,
-            ],
-        )
+        create_namespaces(&catalog, &vec![
+            &namespace_ident_a,
+            &namespace_ident_a_b,
+            &namespace_ident_a_b_c,
+        ])
         .await;
 
         let src_table_ident = TableIdent::new(namespace_ident_a_b_c.clone(), "tbl1".into());
diff --git a/crates/catalog/inmemory/src/namespace_state.rs b/crates/catalog/inmemory/src/namespace_state.rs
index 875e0c7e4..a65319568 100644
--- a/crates/catalog/inmemory/src/namespace_state.rs
+++ b/crates/catalog/inmemory/src/namespace_state.rs
@@ -15,9 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::collections::{hash_map, HashMap};
+
 use iceberg::{Error, ErrorKind, NamespaceIdent, Result, TableIdent};
 use itertools::Itertools;
-use std::collections::{hash_map, HashMap};
 
 // Represents the state of a namespace
 #[derive(Debug, Clone, Default)]