add tests for tree_item_to_span

database-tree/src/databasetreeitems.rs

@@ -52,7 +52,7 @@ impl DatabaseTreeItems {
                 Self::push_databases(e, &mut items, &mut items_added, collapsed)?;
             }
             for table in &e.tables {
-                items.push(DatabaseTreeItem::new_table(e, table)?);
+                items.push(DatabaseTreeItem::new_table(e, table));
             }
         }
 
@@ -84,7 +84,7 @@ impl DatabaseTreeItems {
             *items_added.entry(database.name.clone()).or_insert(0) += 1;
 
             let is_collapsed = collapsed.contains(&c);
-            nodes.push(DatabaseTreeItem::new_database(database, is_collapsed)?);
+            nodes.push(DatabaseTreeItem::new_database(database, is_collapsed));
         }
 
         // increase child count in parent node (the above ancenstor ignores the leaf component)

database-tree/src/item.rs

@@ -1,6 +1,4 @@
-use crate::error::Result;
 use crate::{Database, Table};
-use std::convert::TryFrom;
 
 #[derive(Debug, Clone)]
 pub struct TreeItemInfo {
@@ -76,26 +74,24 @@ pub struct DatabaseTreeItem {
 }
 
 impl DatabaseTreeItem {
-    pub fn new_table(database: &Database, table: &Table) -> Result<Self> {
-        let indent = u8::try_from((3_usize).saturating_sub(2))?;
-
-        Ok(Self {
-            info: TreeItemInfo::new(indent, false),
+    pub fn new_table(database: &Database, table: &Table) -> Self {
+        Self {
+            info: TreeItemInfo::new(1, false),
             kind: DatabaseTreeItemKind::Table {
                 database: database.clone(),
                 table: table.clone(),
             },
-        })
+        }
     }
 
-    pub fn new_database(database: &Database, _collapsed: bool) -> Result<Self> {
-        Ok(Self {
+    pub fn new_database(database: &Database, _collapsed: bool) -> Self {
+        Self {
             info: TreeItemInfo::new(0, true),
             kind: DatabaseTreeItemKind::Database {
                 name: database.name.to_string(),
                 collapsed: true,
             },
-        })
+        }
     }
 
     pub fn set_collapsed(&mut self, collapsed: bool) {

src/components/databases.rs

@@ -332,3 +332,162 @@ fn tree_nav(tree: &mut DatabaseTree, key: Key, key_config: &KeyConfig) -> bool {
         false
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::{Color, Database, DatabaseTreeItem, DatabasesComponent, Span, Spans, Style};
+    use database_tree::Table;
+
+    #[test]
+    fn test_tree_database_tree_item_to_span() {
+        const WIDTH: u16 = 10;
+        assert_eq!(
+            DatabasesComponent::tree_item_to_span(
+                DatabaseTreeItem::new_database(
+                    &Database {
+                        name: "foo".to_string(),
+                        tables: Vec::new(),
+                    },
+                    false,
+                ),
+                false,
+                WIDTH,
+                None,
+            ),
+            Spans::from(vec![Span::raw(format!(
+                "\u{25b8}{:w$}",
+                "foo",
+                w = WIDTH as usize
+            ))])
+        );
+
+        assert_eq!(
+            DatabasesComponent::tree_item_to_span(
+                DatabaseTreeItem::new_database(
+                    &Database {
+                        name: "foo".to_string(),
+                        tables: Vec::new(),
+                    },
+                    false,
+                ),
+                true,
+                WIDTH,
+                None,
+            ),
+            Spans::from(vec![Span::styled(
+                format!("\u{25b8}{:w$}", "foo", w = WIDTH as usize),
+                Style::default().bg(Color::Blue)
+            )])
+        );
+    }
+
+    #[test]
+    fn test_tree_table_tree_item_to_span() {
+        const WIDTH: u16 = 10;
+        assert_eq!(
+            DatabasesComponent::tree_item_to_span(
+                DatabaseTreeItem::new_table(
+                    &Database {
+                        name: "foo".to_string(),
+                        tables: Vec::new(),
+                    },
+                    &Table {
+                        name: "bar".to_string(),
+                        create_time: None,
+                        update_time: None,
+                        engine: None,
+                    },
+                ),
+                false,
+                WIDTH,
+                None,
+            ),
+            Spans::from(vec![Span::raw(format!(
+                "  {:w$}",
+                "bar",
+                w = WIDTH as usize
+            ))])
+        );
+
+        assert_eq!(
+            DatabasesComponent::tree_item_to_span(
+                DatabaseTreeItem::new_table(
+                    &Database {
+                        name: "foo".to_string(),
+                        tables: Vec::new(),
+                    },
+                    &Table {
+                        name: "bar".to_string(),
+                        create_time: None,
+                        update_time: None,
+                        engine: None,
+                    },
+                ),
+                true,
+                WIDTH,
+                None,
+            ),
+            Spans::from(Span::styled(
+                format!("  {:w$}", "bar", w = WIDTH as usize),
+                Style::default().bg(Color::Blue),
+            ))
+        );
+    }
+
+    #[test]
+    fn test_filterd_tree_item_to_span() {
+        const WIDTH: u16 = 10;
+        assert_eq!(
+            DatabasesComponent::tree_item_to_span(
+                DatabaseTreeItem::new_table(
+                    &Database {
+                        name: "foo".to_string(),
+                        tables: Vec::new(),
+                    },
+                    &Table {
+                        name: "barbaz".to_string(),
+                        create_time: None,
+                        update_time: None,
+                        engine: None,
+                    },
+                ),
+                false,
+                WIDTH,
+                Some("rb".to_string()),
+            ),
+            Spans::from(vec![
+                Span::raw(format!("  {}", "ba")),
+                Span::styled("rb", Style::default().fg(Color::Blue)),
+                Span::raw(format!("{:w$}", "az", w = WIDTH as usize))
+            ])
+        );
+
+        assert_eq!(
+            DatabasesComponent::tree_item_to_span(
+                DatabaseTreeItem::new_table(
+                    &Database {
+                        name: "foo".to_string(),
+                        tables: Vec::new(),
+                    },
+                    &Table {
+                        name: "barbaz".to_string(),
+                        create_time: None,
+                        update_time: None,
+                        engine: None,
+                    },
+                ),
+                true,
+                WIDTH,
+                Some("rb".to_string()),
+            ),
+            Spans::from(vec![
+                Span::styled(format!("  {}", "ba"), Style::default().bg(Color::Blue)),
+                Span::styled("rb", Style::default().bg(Color::Blue).fg(Color::Blue)),
+                Span::styled(
+                    format!("{:w$}", "az", w = WIDTH as usize),
+                    Style::default().bg(Color::Blue)
+                )
+            ])
+        );
+    }
+}