Added unit tests for all the new widgets

src/ui/widgets/button.rs

@@ -5,6 +5,10 @@ use ratatui::layout::{Alignment, Constraint, Flex, Layout, Rect};
 use ratatui::prelude::{Style, Styled, Text, Widget};
 use ratatui::widgets::Paragraph;
 
+#[cfg(test)]
+#[path = "button_tests.rs"]
+mod button_tests;
+
 #[derive(Default)]
 pub struct Button<'a> {
   title: &'a str,

src/ui/widgets/button_tests.rs

@@ -0,0 +1,41 @@
+#[cfg(test)]
+mod tests {
+  use crate::ui::widgets::button::Button;
+  use pretty_assertions::{assert_eq, assert_str_eq};
+  use ratatui::style::{Style, Stylize};
+
+  #[test]
+  fn test_title() {
+    let button = Button::default().title("Title");
+
+    assert_str_eq!(button.title, "Title");
+  }
+
+  #[test]
+  fn test_label() {
+    let button = Button::default().label("Label");
+
+    assert_eq!(button.label, Some("Label"));
+  }
+
+  #[test]
+  fn test_icon() {
+    let button = Button::default().icon("Icon");
+
+    assert_eq!(button.icon, Some("Icon"));
+  }
+
+  #[test]
+  fn test_style() {
+    let button = Button::default().style(Style::new().bold());
+
+    assert_eq!(button.style, Style::new().bold());
+  }
+
+  #[test]
+  fn test_selected() {
+    let button = Button::default().selected(true);
+
+    assert!(button.is_selected);
+  }
+}

src/ui/widgets/checkbox.rs

@@ -6,6 +6,10 @@ use ratatui::prelude::Text;
 use ratatui::style::Stylize;
 use ratatui::widgets::{Paragraph, Widget};
 
+#[cfg(test)]
+#[path = "checkbox_tests.rs"]
+mod checkbox_tests;
+
 pub struct Checkbox<'a> {
   label: &'a str,
   is_checked: bool,

src/ui/widgets/checkbox_tests.rs

@@ -0,0 +1,32 @@
+#[cfg(test)]
+mod tests {
+  use crate::ui::widgets::checkbox::Checkbox;
+  use pretty_assertions::assert_str_eq;
+
+  #[test]
+  fn test_checkbox_new() {
+    let checkbox = Checkbox::new("test");
+
+    assert_str_eq!(checkbox.label, "test");
+    assert!(!checkbox.is_checked);
+    assert!(!checkbox.is_highlighted);
+  }
+
+  #[test]
+  fn test_checkbox_checked() {
+    let checkbox = Checkbox::new("test").checked(true);
+
+    assert_str_eq!(checkbox.label, "test");
+    assert!(checkbox.is_checked);
+    assert!(!checkbox.is_highlighted);
+  }
+
+  #[test]
+  fn test_checkbox_highlighted() {
+    let checkbox = Checkbox::new("test").highlighted(true);
+
+    assert_str_eq!(checkbox.label, "test");
+    assert!(!checkbox.is_checked);
+    assert!(checkbox.is_highlighted);
+  }
+}

src/ui/widgets/error_message.rs

@@ -6,6 +6,10 @@ use ratatui::style::Stylize;
 use ratatui::text::Text;
 use ratatui::widgets::{Paragraph, Widget};
 
+#[cfg(test)]
+#[path = "error_message_tests.rs"]
+mod error_message_tests;
+
 pub struct ErrorMessage<'a> {
   text: Text<'a>,
 }

src/ui/widgets/error_message_tests.rs

@@ -0,0 +1,14 @@
+#[cfg(test)]
+mod tests {
+  use crate::ui::widgets::error_message::ErrorMessage;
+  use pretty_assertions::assert_eq;
+  use ratatui::text::Text;
+
+  #[test]
+  fn test_error_message_new() {
+    let message = "This is an error message";
+    let error_message = ErrorMessage::new(message);
+
+    assert_eq!(error_message.text, Text::from(message));
+  }
+}

src/ui/widgets/input_box.rs

@@ -8,6 +8,10 @@ use ratatui::Frame;
 use crate::ui::styles::ManagarrStyle;
 use crate::ui::utils::{borderless_block, layout_block};
 
+#[cfg(test)]
+#[path = "input_box_tests.rs"]
+mod input_box_tests;
+
 pub struct InputBox<'a> {
   content: &'a str,
   offset: usize,

src/ui/widgets/input_box_tests.rs

@@ -0,0 +1,127 @@
+#[cfg(test)]
+mod tests {
+  use crate::ui::styles::ManagarrStyle;
+  use crate::ui::utils::layout_block;
+  use crate::ui::widgets::input_box::InputBox;
+  use pretty_assertions::{assert_eq, assert_str_eq};
+  use ratatui::style::Style;
+
+  #[test]
+  fn test_input_box_new() {
+    let input_box = InputBox::new("test");
+
+    assert_str_eq!(input_box.content, "test");
+    assert_eq!(input_box.offset, 0);
+    assert_eq!(input_box.style, Style::new().default());
+    assert_eq!(input_box.block, layout_block());
+    assert_eq!(input_box.label, None);
+    assert!(input_box.cursor_after_string);
+    assert_eq!(input_box.is_highlighted, None);
+    assert_eq!(input_box.is_selected, None);
+  }
+
+  #[test]
+  fn test_input_box_style() {
+    let input_box = InputBox::new("test").style(Style::new().highlight());
+
+    assert_eq!(input_box.style, Style::new().highlight());
+    assert_str_eq!(input_box.content, "test");
+    assert_eq!(input_box.offset, 0);
+    assert_eq!(input_box.block, layout_block());
+    assert_eq!(input_box.label, None);
+    assert!(input_box.cursor_after_string);
+    assert_eq!(input_box.is_highlighted, None);
+    assert_eq!(input_box.is_selected, None);
+  }
+
+  #[test]
+  fn test_input_box_block() {
+    let input_box = InputBox::new("test").block(layout_block().title("title"));
+
+    assert_eq!(input_box.block, layout_block().title("title"));
+    assert_str_eq!(input_box.content, "test");
+    assert_eq!(input_box.offset, 0);
+    assert_eq!(input_box.style, Style::new().default());
+    assert_eq!(input_box.label, None);
+    assert!(input_box.cursor_after_string);
+    assert_eq!(input_box.is_highlighted, None);
+    assert_eq!(input_box.is_selected, None);
+  }
+
+  #[test]
+  fn test_input_box_label() {
+    let input_box = InputBox::new("test").label("label");
+
+    assert_str_eq!(input_box.label.unwrap(), "label");
+    assert_str_eq!(input_box.content, "test");
+    assert_eq!(input_box.offset, 0);
+    assert_eq!(input_box.style, Style::new().default());
+    assert_eq!(input_box.block, layout_block());
+    assert!(input_box.cursor_after_string);
+    assert_eq!(input_box.is_highlighted, None);
+    assert_eq!(input_box.is_selected, None);
+  }
+
+  #[test]
+  fn test_input_box_offset() {
+    let input_box = InputBox::new("test").offset(1);
+
+    assert_eq!(input_box.offset, 1);
+    assert_str_eq!(input_box.content, "test");
+    assert_eq!(input_box.style, Style::new().default());
+    assert_eq!(input_box.block, layout_block());
+    assert_eq!(input_box.label, None);
+    assert!(input_box.cursor_after_string);
+    assert_eq!(input_box.is_highlighted, None);
+    assert_eq!(input_box.is_selected, None);
+  }
+
+  #[test]
+  fn test_input_box_cursor_after_string() {
+    let input_box = InputBox::new("test").cursor_after_string(false);
+
+    assert!(!input_box.cursor_after_string);
+    assert_str_eq!(input_box.content, "test");
+    assert_eq!(input_box.offset, 0);
+    assert_eq!(input_box.style, Style::new().default());
+    assert_eq!(input_box.block, layout_block());
+    assert_eq!(input_box.label, None);
+    assert_eq!(input_box.is_highlighted, None);
+    assert_eq!(input_box.is_selected, None);
+  }
+
+  #[test]
+  fn test_input_box_highlighted() {
+    let input_box = InputBox::new("test").highlighted(true);
+
+    assert_eq!(input_box.is_highlighted, Some(true));
+    assert_str_eq!(input_box.content, "test");
+    assert_eq!(input_box.offset, 0);
+    assert_eq!(input_box.style, Style::new().default());
+    assert_eq!(input_box.block, layout_block());
+    assert_eq!(input_box.label, None);
+    assert!(input_box.cursor_after_string);
+    assert_eq!(input_box.is_selected, None);
+  }
+
+  #[test]
+  fn test_input_box_selected() {
+    let input_box = InputBox::new("test").selected(true);
+
+    assert_eq!(input_box.is_selected, Some(true));
+    assert_str_eq!(input_box.content, "test");
+    assert_eq!(input_box.offset, 0);
+    assert_eq!(input_box.style, Style::new().default());
+    assert_eq!(input_box.block, layout_block());
+    assert_eq!(input_box.label, None);
+    assert!(input_box.cursor_after_string);
+    assert_eq!(input_box.is_highlighted, None);
+  }
+
+  #[test]
+  fn test_input_box_is_selected() {
+    let input_box = InputBox::new("test").selected(true);
+
+    assert!(input_box.is_selected());
+  }
+}

src/ui/widgets/loading_block.rs

@@ -4,6 +4,10 @@ use ratatui::layout::Rect;
 use ratatui::prelude::Text;
 use ratatui::widgets::{Block, Paragraph, Widget};
 
+#[cfg(test)]
+#[path = "loading_block_tests.rs"]
+mod loading_block_tests;
+
 pub struct LoadingBlock<'a> {
   is_loading: bool,
   block: Block<'a>,

src/ui/widgets/loading_block_tests.rs

@@ -0,0 +1,14 @@
+#[cfg(test)]
+mod tests {
+  use crate::ui::utils::layout_block;
+  use crate::ui::widgets::loading_block::LoadingBlock;
+  use pretty_assertions::assert_eq;
+
+  #[test]
+  fn test_loading_block_new() {
+    let loading_block = LoadingBlock::new(true, layout_block());
+
+    assert_eq!(loading_block.is_loading, true);
+    assert_eq!(loading_block.block, layout_block());
+  }
+}

src/ui/widgets/managarr_table.rs

@@ -11,6 +11,10 @@ use ratatui::prelude::{Style, Stylize, Text};
 use ratatui::widgets::{Block, ListItem, Paragraph, Row, StatefulWidget, Table, Widget};
 use std::fmt::Debug;
 
+#[cfg(test)]
+#[path = "managarr_table_tests.rs"]
+mod managarr_table_tests;
+
 pub struct ManagarrTable<'a, T, F>
 where
   F: Fn(&T) -> Row<'a>,

src/ui/widgets/managarr_table_tests.rs

@@ -0,0 +1,314 @@
+#[cfg(test)]
+mod tests {
+  use crate::models::stateful_list::StatefulList;
+  use crate::models::stateful_table::{SortOption, StatefulTable};
+  use crate::models::Scrollable;
+  use crate::ui::utils::layout_block;
+  use crate::ui::widgets::managarr_table::ManagarrTable;
+  use pretty_assertions::assert_eq;
+  use ratatui::layout::{Alignment, Constraint};
+  use ratatui::text::Text;
+  use ratatui::widgets::{Block, Cell, Row};
+
+  #[test]
+  fn test_managarr_table_new() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]));
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_headers() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+    let headers = ["column 1", "column 2"];
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .headers(headers.clone());
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.table_headers, headers);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_constraints() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+    let constraints = [Constraint::Length(1), Constraint::Fill(1)];
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .constraints(constraints.clone());
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.constraints, constraints);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_footer() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+    let footer = "footer".to_owned();
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .footer(Some(footer.clone()));
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.footer, Some(footer));
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_footer_alignment() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .footer_alignment(Alignment::Center);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.footer_alignment, Alignment::Center);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_block() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .block(layout_block());
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.block, layout_block());
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_margin() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)])).margin(1);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert_eq!(managarr_table.margin, 1);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_loading() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .loading(true);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert!(managarr_table.is_loading);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(managarr_table.highlight_rows);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_highlight_rows() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .highlight_rows(false);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert!(!managarr_table.highlight_rows);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(!managarr_table.is_sorting);
+  }
+
+  #[test]
+  fn test_managarr_table_sorting() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .sorting(true);
+
+    let row_mapper = managarr_table.row_mapper;
+    assert!(managarr_table.is_sorting);
+    assert_eq!(managarr_table.content.unwrap().items, items);
+    assert_eq!(row_mapper(&"item1"), Row::new(vec![Cell::new("item1")]));
+    assert_eq!(managarr_table.table_headers, Vec::<String>::new());
+    assert_eq!(managarr_table.constraints, Vec::new());
+    assert_eq!(managarr_table.footer, None);
+    assert_eq!(managarr_table.footer_alignment, Alignment::Left);
+    assert_eq!(managarr_table.block, Block::new());
+    assert_eq!(managarr_table.margin, 0);
+    assert!(!managarr_table.is_loading);
+    assert!(managarr_table.highlight_rows);
+  }
+
+  #[test]
+  fn test_managarr_table_parse_headers() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut sort_list = StatefulList::default();
+    sort_list.set_items(vec![
+      SortOption {
+        name: "column 1",
+        cmp_fn: None,
+      },
+      SortOption {
+        name: "column 2",
+        cmp_fn: None,
+      },
+    ]);
+    sort_list.scroll_down();
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+    stateful_table.sort = Some(sort_list);
+    let headers = ["column 1", "column 2"];
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .headers(headers);
+
+    assert_eq!(
+      managarr_table.parse_headers(),
+      vec![Text::from("column 1"), Text::from("column 2 ▼")]
+    );
+  }
+
+  #[test]
+  fn test_managarr_table_parse_headers_ascending() {
+    let items = vec!["item1", "item2", "item3"];
+    let mut sort_list = StatefulList::default();
+    sort_list.set_items(vec![
+      SortOption {
+        name: "column 1",
+        cmp_fn: None,
+      },
+      SortOption {
+        name: "column 2",
+        cmp_fn: None,
+      },
+    ]);
+    sort_list.scroll_down();
+    let mut stateful_table = StatefulTable::default();
+    stateful_table.set_items(items.clone());
+    stateful_table.sort = Some(sort_list);
+    stateful_table.sort_asc = true;
+    let headers = ["column 1", "column 2"];
+
+    let managarr_table =
+      ManagarrTable::new(Some(&mut stateful_table), |&s| Row::new(vec![Cell::new(s)]))
+        .headers(headers);
+
+    assert_eq!(
+      managarr_table.parse_headers(),
+      vec![Text::from("column 1"), Text::from("column 2 ▲")]
+    );
+  }
+}

src/ui/widgets/popup.rs

@@ -3,6 +3,10 @@ use ratatui::buffer::Buffer;
 use ratatui::layout::Rect;
 use ratatui::widgets::{Clear, Widget};
 
+#[cfg(test)]
+#[path = "popup_tests.rs"]
+mod popup_tests;
+
 pub struct Popup<T: Widget> {
   widget: T,
   percent_x: u16,

src/ui/widgets/popup_tests.rs

@@ -0,0 +1,15 @@
+#[cfg(test)]
+mod tests {
+  use crate::ui::widgets::popup::Popup;
+  use pretty_assertions::assert_eq;
+  use ratatui::widgets::Block;
+
+  #[test]
+  fn test_popup_new() {
+    let popup = Popup::new(Block::new(), 50, 50);
+
+    assert_eq!(popup.widget, Block::new());
+    assert_eq!(popup.percent_x, 50);
+    assert_eq!(popup.percent_y, 50);
+  }
+}

src/ui/widgets/selectable_list.rs

@@ -7,6 +7,10 @@ use ratatui::prelude::Widget;
 use ratatui::style::Style;
 use ratatui::widgets::{List, ListItem, StatefulWidget};
 
+#[cfg(test)]
+#[path = "selectable_list_tests.rs"]
+mod selectable_list_tests;
+
 pub struct SelectableList<'a, T, F>
 where
   F: Fn(&T) -> ListItem<'a>,
@@ -32,7 +36,7 @@ where
     let selectable_list = List::new(items)
       .block(layout_block())
       .highlight_style(Style::new().highlight());
-    
+
     StatefulWidget::render(selectable_list, area, buf, &mut self.content.state);
   }
 }

src/ui/widgets/selectable_list_tests.rs

@@ -0,0 +1,21 @@
+#[cfg(test)]
+mod tests {
+  use crate::models::stateful_list::StatefulList;
+  use crate::ui::widgets::selectable_list::SelectableList;
+  use pretty_assertions::assert_eq;
+  use ratatui::widgets::ListItem;
+
+  #[test]
+  fn test_selectable_list_new() {
+    let items = vec!["test"];
+    let mut stateful_list = StatefulList::default();
+    stateful_list.set_items(items.clone());
+
+    let selectable_list =
+      SelectableList::new(&mut stateful_list, |item| ListItem::new(item.to_string()));
+
+    let row_mapper = selectable_list.row_mapper;
+    assert_eq!(selectable_list.content.items, items);
+    assert_eq!(row_mapper(&"test"), ListItem::new("test"));
+  }
+}