move application tests closer to... the application. Nice!

1 files changed, 0 insertions, 329 deletions

diff --git a/tests/interactive.rs b/tests/interactive.rs
deleted file mode 100644
index 5210c9b..0000000
--- a/tests/interactive.rs
+++ /dev/null
@@ -1,329 +0,0 @@
-mod app {
-    use dua::{
-        interactive::TerminalApp,
-        traverse::{EntryData, Tree, TreeIndex},
-        ByteFormat, Color, SortMode, TraversalSorting, WalkOptions,
-    };
-    use failure::Error;
-    use petgraph::prelude::NodeIndex;
-    use pretty_assertions::assert_eq;
-    use std::{ffi::OsStr, ffi::OsString, fmt, path::Path, path::PathBuf};
-    use termion::input::TermRead;
-    use tui::{backend::TestBackend, Terminal};
-
-    const FIXTURE_PATH: &'static str = "tests/fixtures";
-
-    fn debug(item: impl fmt::Debug) -> String {
-        format!("{:?}", item)
-    }
-
-    #[test]
-    fn it_can_handle_ending_traversal_reaching_top_but_skipping_levels() -> Result<(), Error> {
-        let (_, app) = initialized_app_and_terminal(&["sample-01"])?;
-        let expected_tree = sample_01_tree();
-
-        assert_eq!(
-            debug(app.traversal.tree),
-            debug(expected_tree),
-            "filesystem graph is stable and matches the directory structure"
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn it_can_handle_ending_traversal_without_reaching_the_top() -> Result<(), Error> {
-        let (_, app) = initialized_app_and_terminal(&["sample-02"])?;
-        let expected_tree = sample_02_tree();
-
-        assert_eq!(
-            debug(app.traversal.tree),
-            debug(expected_tree),
-            "filesystem graph is stable and matches the directory structure"
-        );
-        Ok(())
-    }
-
-    fn node_by_index(app: &TerminalApp, id: TreeIndex) -> &EntryData {
-        app.traversal.tree.node_weight(id).unwrap()
-    }
-
-    fn node_by_name(app: &TerminalApp, name: impl AsRef<OsStr>) -> &EntryData {
-        node_by_index(app, index_by_name(&app, name))
-    }
-
-    fn index_by_name_and_size(
-        app: &TerminalApp,
-        name: impl AsRef<OsStr>,
-        size: Option<u64>,
-    ) -> TreeIndex {
-        let name = name.as_ref();
-        let t: Vec<_> = app
-            .traversal
-            .tree
-            .node_indices()
-            .map(|idx| (idx, node_by_index(app, idx)))
-            .filter_map(|(idx, e)| {
-                if e.name == name
-                    && match size {
-                        Some(s) => s == e.size,
-                        None => true,
-                    }
-                {
-                    Some(idx)
-                } else {
-                    None
-                }
-            })
-            .collect();
-        match t.len() {
-            1 => t[0],
-            0 => panic!("Node named '{}' not found in tree", name.to_string_lossy()),
-            n => panic!("Node named '{}' found {} times", name.to_string_lossy(), n),
-        }
-    }
-    fn index_by_name(app: &TerminalApp, name: impl AsRef<OsStr>) -> TreeIndex {
-        index_by_name_and_size(app, name, None)
-    }
-
-    #[test]
-    fn simple_user_journey() -> Result<(), Error> {
-        let long_root = "sample-02/dir";
-        let short_root = "sample-01";
-        let (mut terminal, mut app) = initialized_app_and_terminal(&[short_root, long_root])?;
-
-        // POST-INIT
-        // after initialization, we expect that...
-        {
-            assert_eq!(
-                app.state.sorting,
-                SortMode::SizeDescending,
-                "it will sort entries in descending order by size"
-            );
-
-            let first_selected_path = OsString::from(format!("{}/{}", FIXTURE_PATH, long_root));
-            assert_eq!(
-                node_by_name(&app, &first_selected_path).name,
-                first_selected_path,
-                "the roots are always listed with the given (possibly long) names",
-            );
-
-            assert_eq!(
-                node_by_name(&app, fixture_str(short_root)),
-                node_by_index(&app, *app.state.selected.as_ref().unwrap()),
-                "it selects the first node in the list",
-            );
-
-            assert_eq!(
-                app.traversal.root_index, app.state.root,
-                "the root is the 'virtual' root",
-            );
-        }
-
-        // SORTING
-        {
-            // when hitting the S key
-            app.process_events(&mut terminal, b"s".keys())?;
-            assert_eq!(
-                app.state.sorting,
-                SortMode::SizeAscending,
-                "it sets the sort mode to ascending by size"
-            );
-            // when hitting the S key again
-            app.process_events(&mut terminal, b"s".keys())?;
-            assert_eq!(
-                app.state.sorting,
-                SortMode::SizeDescending,
-                "it sets the sort mode to descending by size"
-            );
-        }
-
-        // Entry-Navigation
-        {
-            // when hitting the j key
-            app.process_events(&mut terminal, b"j".keys())?;
-            assert_eq!(
-                node_by_name(&app, fixture_str(long_root)),
-                node_by_index(&app, *app.state.selected.as_ref().unwrap()),
-                "it moves the cursor down and selects the next entry based on the current sort mode"
-            );
-            // when hitting it while there is nowhere to go
-            app.process_events(&mut terminal, b"j".keys())?;
-            assert_eq!(
-                node_by_name(&app, fixture_str(long_root)),
-                node_by_index(&app, *app.state.selected.as_ref().unwrap()),
-                "it stays at the previous position"
-            );
-            // when hitting the k key
-            app.process_events(&mut terminal, b"k".keys())?;
-            assert_eq!(
-                node_by_name(&app, fixture_str(short_root)),
-                node_by_index(&app, *app.state.selected.as_ref().unwrap()),
-                "it moves the cursor up and selects the next entry based on the current sort mode"
-            );
-            // when hitting the k key again
-            app.process_events(&mut terminal, b"k".keys())?;
-            assert_eq!(
-                node_by_name(&app, fixture_str(short_root)),
-                node_by_index(&app, *app.state.selected.as_ref().unwrap()),
-                "it stays at the current cursor position as there is nowhere to go"
-            );
-            // when hitting the o key with a directory selected
-            app.process_events(&mut terminal, b"o".keys())?;
-            {
-                let new_root_idx = index_by_name(&app, fixture_str(short_root));
-                assert_eq!(
-                    new_root_idx, app.state.root,
-                    "it enters the entry if it is a directory, changing the root"
-                );
-                assert_eq!(
-                    index_by_name(&app, "dir"),
-                    *app.state.selected.as_ref().unwrap(),
-                    "it selects the first entry in the directory"
-                );
-
-                // when hitting the u key while inside a sub-directory
-                app.process_events(&mut terminal, b"u".keys())?;
-                {
-                    assert_eq!(
-                        app.traversal.root_index,
-                        app.state.root,
-                        "it sets the root to be the (roots) parent directory, being the virtual root"
-                    );
-                    assert_eq!(
-                        node_by_name(&app, fixture_str(short_root)),
-                        node_by_index(&app, *app.state.selected.as_ref().unwrap()),
-                        "changes the selection to the first item in the list of entries"
-                    );
-                }
-            }
-            // when hitting the u key while inside of the root directory
-            // We are moving the cursor down just to have a non-default selection
-            app.process_events(&mut terminal, b"ju".keys())?;
-            {
-                assert_eq!(
-                    app.traversal.root_index, app.state.root,
-                    "it keeps the root - it can't go further up"
-                );
-                assert_eq!(
-                    node_by_name(&app, fixture_str(long_root)),
-                    node_by_index(&app, *app.state.selected.as_ref().unwrap()),
-                    "keeps the previous selection"
-                );
-            }
-        }
-
-        Ok(())
-    }
-
-    fn fixture(p: impl AsRef<Path>) -> PathBuf {
-        Path::new(FIXTURE_PATH).join(p)
-    }
-
-    fn fixture_str(p: impl AsRef<Path>) -> String {
-        fixture(p).to_str().unwrap().to_owned()
-    }
-
-    fn initialized_app_and_terminal(
-        fixture_paths: &[&str],
-    ) -> Result<(Terminal<TestBackend>, TerminalApp), Error> {
-        let mut terminal = Terminal::new(TestBackend::new(40, 20))?;
-        std::env::set_current_dir(Path::new(env!("CARGO_MANIFEST_DIR")))?;
-
-        let input = fixture_paths.iter().map(fixture).collect();
-        let app = TerminalApp::initialize(
-            &mut terminal,
-            WalkOptions {
-                threads: 1,
-                byte_format: ByteFormat::Metric,
-                color: Color::None,
-                sorting: TraversalSorting::AlphabeticalByFileName,
-            },
-            input,
-        )?;
-        Ok((terminal, app))
-    }
-
-    fn sample_01_tree() -> Tree {
-        let mut t = Tree::new();
-        {
-            let mut add_node = make_add_node(&mut t);
-            let root_size = 1259070;
-            let r = add_node("", root_size, None);
-            {
-                let s = add_node(&fixture_str("sample-01"), root_size, Some(r));
-                {
-                    add_node(".hidden.666", 666, Some(s));
-                    add_node("a", 256, Some(s));
-                    add_node("b.empty", 0, Some(s));
-                    add_node("c.lnk", 1, Some(s));
-                    let d = add_node("dir", 1258024, Some(s));
-                    {
-                        add_node("1000bytes", 1000, Some(d));
-                        add_node("dir-a.1mb", 1_000_000, Some(d));
-                        add_node("dir-a.kb", 1024, Some(d));
-                        let e = add_node("empty-dir", 0, Some(d));
-                        {
-                            add_node(".gitkeep", 0, Some(e));
-                        }
-                        let sub = add_node("sub", 256_000, Some(d));
-                        {
-                            add_node("dir-sub-a.256kb", 256_000, Some(sub));
-                        }
-                    }
-                    add_node("z123.b", 123, Some(s));
-                }
-            }
-        }
-        t
-    }
-    fn sample_02_tree() -> Tree {
-        let mut t = Tree::new();
-        {
-            let mut add_node = make_add_node(&mut t);
-            let root_size = 1540;
-            let r = add_node("", root_size, None);
-            {
-                let s = add_node(
-                    format!("{}/{}", FIXTURE_PATH, "sample-02").as_str(),
-                    root_size,
-                    Some(r),
-                );
-                {
-                    add_node("a", 256, Some(s));
-                    add_node("b", 1, Some(s));
-                    let d = add_node("dir", 1283, Some(s));
-                    {
-                        add_node("c", 257, Some(d));
-                        add_node("d", 2, Some(d));
-                        let e = add_node("empty-dir", 0, Some(d));
-                        {
-                            add_node(".gitkeep", 0, Some(e));
-                        }
-                        let sub = add_node("sub", 1024, Some(d));
-                        {
-                            add_node("e", 1024, Some(sub));
-                        }
-                    }
-                }
-            }
-        }
-        t
-    }
-
-    fn make_add_node<'a>(
-        t: &'a mut Tree,
-    ) -> impl FnMut(&str, u64, Option<NodeIndex>) -> NodeIndex + 'a {
-        move |name, size, maybe_from_idx| {
-            let n = t.add_node(EntryData {
-                name: OsString::from(name),
-                size,
-                metadata_io_error: false,
-            });
-            if let Some(from) = maybe_from_idx {
-                t.add_edge(from, n, ());
-            }
-            n
-        }
-    }
-
-}