refactor(tests): remove code duplications (#55)

* moved keyboard_events_to_utils

* refactored ui keyboard events

* refactored raw mod

* format

* renamed sleep events function

* refactored OsInputOutput

* refactored opts

* refactored backend first test

* refactored backend ui tests

* refactored backend raw tests

* simplified terminal events read

* format

4 files changed, 316 insertions, 1294 deletions

diff --git a/src/tests/cases/mod.rs b/src/tests/cases/mod.rs
index 87c141b..91dee6a 100644
--- a/src/tests/cases/mod.rs
+++ b/src/tests/cases/mod.rs
@@ -1,2 +1,3 @@
 pub mod raw_mode;
+pub mod test_utils;
 pub mod ui;
diff --git a/src/tests/cases/raw_mode.rs b/src/tests/cases/raw_mode.rs
index 93c2afa..b2d6d64 100644
--- a/src/tests/cases/raw_mode.rs
+++ b/src/tests/cases/raw_mode.rs
@@ -1,11 +1,7 @@
-use crate::tests::fakes::{
-    create_fake_dns_client, create_fake_on_winch, get_interfaces, get_open_sockets, KeyboardEvents,
-    NetworkFrames, TestBackend,
-};
+use crate::tests::fakes::{create_fake_dns_client, NetworkFrames};
 
 use ::insta::assert_snapshot;
 use ::std::sync::{Arc, Mutex};
-use ::termion::event::{Event, Key};
 
 use ::std::collections::HashMap;
 use ::std::net::IpAddr;
@@ -16,9 +12,11 @@ use pnet::datalink::DataLinkReceiver;
 use pnet::packet::Packet;
 use pnet_base::MacAddr;
 
-use ::std::io::Write;
+use crate::tests::cases::test_utils::{
+    opts_raw, os_input_output_dns, os_input_output_stdout, test_backend_factory,
+};
 
-use crate::{start, Opt, OsInputOutput};
+use crate::{start, Opt};
 
 fn build_tcp_packet(
     source_ip: &str,
@@ -46,26 +44,8 @@ fn format_raw_output(output: Vec<u8>) -> String {
     format!("{}", replaced)
 }
 
-struct LogWithMirror<T> {
-    pub write: Arc<Mutex<T>>,
-    pub mirror: Arc<Mutex<T>>,
-}
-
-impl<T> LogWithMirror<T> {
-    pub fn new(log: T) -> Self {
-        let write = Arc::new(Mutex::new(log));
-        let mirror = write.clone();
-        LogWithMirror { write, mirror }
-    }
-}
-
 #[test]
 fn one_packet_of_traffic() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![Some(build_tcp_packet(
         "10.0.0.2",
         "1.1.1.1",
@@ -73,46 +53,10 @@ fn one_packet_of_traffic() {
         12345,
         b"I am a fake tcp packet",
     ))]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
+    let (_, _, backend) = test_backend_factory(190, 50);
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 2, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -121,11 +65,6 @@ fn one_packet_of_traffic() {
 
 #[test]
 fn bi_directional_traffic() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "10.0.0.2",
@@ -142,46 +81,10 @@ fn bi_directional_traffic() {
             b"I am a fake tcp download packet",
         )),
     ]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
+    let (_, _, backend) = test_backend_factory(190, 50);
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 2, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -190,11 +93,6 @@ fn bi_directional_traffic() {
 
 #[test]
 fn multiple_packets_of_traffic_from_different_connections() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "1.1.1.1",
@@ -211,46 +109,10 @@ fn multiple_packets_of_traffic_from_different_connections() {
             b"I come from 2.2.2.2",
         )),
     ]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
+    let (_, _, backend) = test_backend_factory(190, 50);
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        on_winch,
-        cleanup,
-        keyboard_events,
-        dns_client,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 2, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -259,11 +121,6 @@ fn multiple_packets_of_traffic_from_different_connections() {
 
 #[test]
 fn multiple_packets_of_traffic_from_single_connection() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "1.1.1.1",
@@ -280,46 +137,10 @@ fn multiple_packets_of_traffic_from_single_connection() {
             b"I've come from 1.1.1.1 too!",
         )),
     ]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
+    let (_, _, backend) = test_backend_factory(190, 50);
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 2, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -328,11 +149,6 @@ fn multiple_packets_of_traffic_from_single_connection() {
 
 #[test]
 fn one_process_with_multiple_connections() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "1.1.1.1",
@@ -349,46 +165,10 @@ fn one_process_with_multiple_connections() {
             b"Funny that, I'm from 3.3.3.3",
         )),
     ]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
+    let (_, _, backend) = test_backend_factory(190, 50);
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 2, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -397,11 +177,6 @@ fn one_process_with_multiple_connections() {
 
 #[test]
 fn multiple_processes_with_multiple_connections() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "1.1.1.1",
@@ -432,46 +207,10 @@ fn multiple_processes_with_multiple_connections() {
             b"I'm partial to 4.4.4.4",
         )),
     ]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
+    let (_, _, backend) = test_backend_factory(190, 50);
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 2, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -480,11 +219,6 @@ fn multiple_processes_with_multiple_connections() {
 
 #[test]
 fn multiple_connections_from_remote_address() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "1.1.1.1",
@@ -501,46 +235,11 @@ fn multiple_connections_from_remote_address() {
             b"Me too, but on a different port",
         )),
     ]) as Box<dyn DataLinkReceiver>];
+    let (_, _, backend) = test_backend_factory(190, 50);
 
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 2, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -549,12 +248,6 @@ fn multiple_connections_from_remote_address() {
 
 #[test]
 fn sustained_traffic_from_one_process() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "1.1.1.1",
@@ -572,46 +265,11 @@ fn sustained_traffic_from_one_process() {
             b"Same here, but one second later",
         )),
     ]) as Box<dyn DataLinkReceiver>];
+    let (_, _, backend) = test_backend_factory(190, 50);
 
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 3, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -620,12 +278,6 @@ fn sustained_traffic_from_one_process() {
 
 #[test]
 fn sustained_traffic_from_multiple_processes() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "1.1.1.1",
@@ -657,46 +309,11 @@ fn sustained_traffic_from_multiple_processes() {
             b"I come 3.3.3.3 one second later",
         )),
     ]) as Box<dyn DataLinkReceiver>];
+    let (_, _, backend) = test_backend_factory(190, 50);
 
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_stdout(network_frames, 3, Some(stdout.clone()));
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -705,12 +322,6 @@ fn sustained_traffic_from_multiple_processes() {
 
 #[test]
 fn sustained_traffic_from_multiple_processes_bi_directional() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "10.0.0.2",
@@ -770,46 +381,11 @@ fn sustained_traffic_from_multiple_processes_bi_directional() {
             b"10.0.0.2 forever!",
         )),
     ]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
+    let (_, _, backend) = test_backend_factory(190, 50);
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
+    let os_input = os_input_output_stdout(network_frames, 3, Some(stdout.clone()));
 
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -818,12 +394,6 @@ fn sustained_traffic_from_multiple_processes_bi_directional() {
 
 #[test]
 fn traffic_with_host_names() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "10.0.0.2",
@@ -883,19 +453,7 @@ fn traffic_with_host_names() {
             b"10.0.0.2 forever!",
         )),
     ]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
+    let (_, _, backend) = test_backend_factory(190, 50);
     let mut ips_to_hostnames = HashMap::new();
     ips_to_hostnames.insert(
         IpAddr::V4("1.1.1.1".parse().unwrap()),
@@ -910,32 +468,9 @@ fn traffic_with_host_names() {
         String::from("i-like-cheese.com"),
     );
     let dns_client = create_fake_dns_client(ips_to_hostnames);
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
     let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: true,
-        no_resolve: false,
-    };
+    let os_input = os_input_output_dns(network_frames, 3, Some(stdout.clone()), dns_client);
+    let opts = opts_raw();
     start(backend, os_input, opts);
     let stdout = Arc::try_unwrap(stdout).unwrap().into_inner().unwrap();
     let formatted = format_raw_output(stdout);
@@ -944,12 +479,6 @@ fn traffic_with_host_names() {
 
 #[test]
 fn no_resolve_mode() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        None, // sleep
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         Some(build_tcp_packet(
             "10.0.0.2",
@@ -1009,19 +538,7 @@ fn no_resolve_mode() {
             b"10.0.0.2 forever!",
         )),
     ]) as Box<dyn DataLinkReceiver>];
-
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
+    let (_, _, backend) = test_backend_factory(190, 50);
     let mut ips_to_hostnames = HashMap::new();
     ips_to_hostnames.insert(
         IpAddr::V4("1.1.1.1".parse().unwrap()),
@@ -1035,28 +552,9 @@ fn no_resolve_mode() {
         IpAddr::V4("10.0.0.2".parse().unwrap()),
         String::from("i-like-cheese.com"),
     );
-    let dns_client = None;
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
-    let stdout = Arc::new(Mutex::new(Vec::new()));
-    let write_to_stdout = Box::new({
-        let stdout = stdout.clone();
-        move |output: String| {
-            let mut stdout = stdout.lock().unwrap();
-            writeln!(&mut stdout, "{}", output).unwrap();
-        }
-    });
 
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
+    let stdout = Arc::new(Mutex::new(Vec::new()));
+    let os_input = os_input_output_dns(network_frames, 3, Some(stdout.clone()), None);
     let opts = Opt {
         interface: Some(String::from("interface_name")),
         raw: true,
diff --git a/src/tests/cases/test_utils.rs b/src/tests/cases/test_utils.rs
new file mode 100644
index 0000000..60b0686
--- /dev/null
+++ b/src/tests/cases/test_utils.rs
@@ -0,0 +1,116 @@
+use crate::tests::fakes::{
+    create_fake_dns_client, create_fake_on_winch, get_interfaces, get_open_sockets, KeyboardEvents,
+    TerminalEvent, TestBackend,
+};
+use std::iter;
+
+use crate::network::dns::Client;
+use crate::{Opt, OsInputOutput};
+use ::termion::event::{Event, Key};
+use pnet::datalink::DataLinkReceiver;
+use std::collections::HashMap;
+use std::io::Write;
+use std::sync::{Arc, Mutex};
+
+pub fn sleep_and_quit_events(sleep_num: usize) -> Box<KeyboardEvents> {
+    let mut events: Vec<Option<Event>> = iter::repeat(None).take(sleep_num).collect();
+    events.push(Some(Event::Key(Key::Ctrl('c'))));
+    Box::new(KeyboardEvents::new(events))
+}
+
+pub fn os_input_output(
+    network_frames: Vec<Box<dyn DataLinkReceiver>>,
+    sleep_num: usize,
+) -> OsInputOutput {
+    os_input_output_factory(
+        network_frames,
+        sleep_num,
+        None,
+        create_fake_dns_client(HashMap::new()),
+    )
+}
+pub fn os_input_output_stdout(
+    network_frames: Vec<Box<dyn DataLinkReceiver>>,
+    sleep_num: usize,
+    stdout: Option<Arc<Mutex<Vec<u8>>>>,
+) -> OsInputOutput {
+    os_input_output_factory(
+        network_frames,
+        sleep_num,
+        stdout,
+        create_fake_dns_client(HashMap::new()),
+    )
+}
+
+pub fn os_input_output_dns(
+    network_frames: Vec<Box<dyn DataLinkReceiver>>,
+    sleep_num: usize,
+    stdout: Option<Arc<Mutex<Vec<u8>>>>,
+    dns_client: Option<Client>,
+) -> OsInputOutput {
+    os_input_output_factory(network_frames, sleep_num, stdout, dns_client)
+}
+
+fn os_input_output_factory(
+    network_frames: Vec<Box<dyn DataLinkReceiver>>,
+    sleep_num: usize,
+    stdout: Option<Arc<Mutex<Vec<u8>>>>,
+    dns_client: Option<Client>,
+) -> OsInputOutput {
+    let on_winch = create_fake_on_winch(false);
+    let cleanup = Box::new(|| {});
+
+    let write_to_stdout: Box<dyn FnMut(String) + Send> = match stdout {
+        Some(stdout) => Box::new({
+            move |output: String| {
+                let mut stdout = stdout.lock().unwrap();
+                writeln!(&mut stdout, "{}", output).unwrap();
+            }
+        }),
+        None => Box::new({ move |_output: String| {} }),
+    };
+
+    OsInputOutput {
+        network_interfaces: get_interfaces(),
+        network_frames,
+        get_open_sockets,
+        keyboard_events: sleep_and_quit_events(sleep_num),
+        dns_client,
+        on_winch,
+        cleanup,
+        write_to_stdout,
+    }
+}
+
+pub fn opts_raw() -> Opt {
+    opts_factory(true)
+}
+
+pub fn opts_ui() -> Opt {
+    opts_factory(false)
+}
+
+fn opts_factory(raw: bool) -> Opt {
+    Opt {
+        interface: Some(String::from("interface_name")),
+        raw,
+        no_resolve: false,
+    }
+}
+type BackendWithStreams = (
+    Arc<Mutex<Vec<TerminalEvent>>>,
+    Arc<Mutex<Vec<String>>>,
+    TestBackend,
+);
+pub fn test_backend_factory(w: u16, h: u16) -> BackendWithStreams {
+    let terminal_events: Arc<Mutex<Vec<TerminalEvent>>> = Arc::new(Mutex::new(Vec::new()));
+    let terminal_draw_events: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
+
+    let backend = TestBackend::new(
+        terminal_events.clone(),
+        terminal_draw_events.clone(),
+        Arc::new(Mutex::new(w)),
+        Arc::new(Mutex::new(h)),
+    );
+    (terminal_events, terminal_draw_events, backend)
+}
diff --git a/src/tests/cases/ui.rs b/src/tests/cases/ui.rs
index b89c28d..2f1f756 100644
--- a/src/tests/cases/ui.rs
+++ b/src/tests/cases/ui.rs
@@ -1,16 +1,16 @@
 use crate::tests::fakes::TerminalEvent::*;
 use crate::tests::fakes::{
-    create_fake_dns_client, create_fake_on_winch, get_interfaces, get_open_sockets, KeyboardEvents,
-    NetworkFrames, TestBackend,
+    create_fake_dns_client, create_fake_on_winch, get_interfaces, get_open_sockets, NetworkFrames,
 };
 
 use ::insta::assert_snapshot;
-use ::std::sync::{Arc, Mutex};
-use ::termion::event::{Event, Key};
 
 use ::std::collections::HashMap;
 use ::std::net::IpAddr;
 
+use crate::tests::cases::test_utils::{
+    opts_ui, os_input_output, sleep_and_quit_events, test_backend_factory,
+};
 use packet_builder::payload::PayloadData;
 use packet_builder::*;
 use pnet::datalink::DataLinkReceiver;
@@ -37,68 +37,23 @@ fn build_tcp_packet(
     pkt.packet().to_vec()
 }
 
-struct LogWithMirror<T> {
-    pub write: Arc<Mutex<T>>,
-    pub mirror: Arc<Mutex<T>>,
-}
-
-impl<T> LogWithMirror<T> {
-    pub fn new(log: T) -> Self {
-        let write = Arc::new(Mutex::new(log));
-        let mirror = write.clone();
-        LogWithMirror { write, mirror }
-    }
-}
-
 #[test]
 fn basic_startup() {
-    let keyboard_events = Box::new(KeyboardEvents::new(vec![
-        None, // sleep
-        Some(Event::Key(Key::Ctrl('c'))),
-    ]));
     let network_frames = vec![NetworkFrames::new(vec![
         None, // sleep
     ]) as Box<dyn DataLinkReceiver>];
 
-    let terminal_width = Arc::new(Mutex::new(190));
-    let terminal_height = Arc::new(Mutex::new(50));
-    let terminal_events = LogWithMirror::new(Vec::new());
-    let terminal_draw_events = LogWithMirror::new(Vec::new());
-
-    let backend = TestBackend::new(
-        terminal_events.write,
-        terminal_draw_events.write,
-        terminal_width,
-        terminal_height,
-    );
-    let network_interfaces = get_interfaces();
-    let dns_client = create_fake_dns_client(HashMap::new());
-    let on_winch = create_fake_on_winch(false);
-    let cleanup = Box::new(|| {});
-    let write_to_stdout = Box::new({ move |_output: String| {} });
-
-    let os_input = OsInputOutput {
-        network_interfaces,
-        network_frames,
-        get_open_sockets,
-        keyboard_events,
-        dns_client,
-        on_winch,
-        cleanup,
-        write_to_stdout,
-    };
-    let opts = Opt {
-        interface: Some(String::from("interface_name")),
-        raw: false,
-        no_resolve: false,
-    };
+    let (terminal_events, terminal_draw_events, backend) = test_backend_factory(190, 50);
+    let os_input = os_input_output(network_frames, 1);
+    let opts = opts_ui();
     start(backend, os_input, opts);
-
-    let terminal_events_mirror = terminal_events.mirror.lock().unwrap();
-    let terminal_draw_events_mirror = terminal_draw_events.mirror.lock().unwrap();