test(cli): add comprehensive CLI integration and unit tests

- add integration tests covering activity flow, error scenarios, and CLI output validation using assert_cmd, predicates, and tempfile.
- add unit tests for formatting, parsing, and edge case handling in models and utility modules.
- fix command argument handling and config injection in tests to use `BOAT_CONFIG` env var.
- update error message assertions for compatibility with current clap output.
- ensure robust duration formatting and corresponding expectation in tests.

Author: coko7

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "boat-cli"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2024"
 description = "Basic Opinionated Activity Tracker, a command line interface inspired by bartib"
 repository = "https://github.com/coko7/boat"
@@ -30,6 +30,11 @@ boat-lib = "0.4.0"
 tabular = { version = "0.2.0", features = ["ansi-cell"] }
 yansi = "1.0.1"
 
+[dev-dependencies]
+assert_cmd = "2.0"
+predicates = "3.0"
+tempfile = "3.8"
+
 [features]
 default = []
 bundled-sqlite = ["boat-lib/bundled-sqlite"]

Cargo.toml

@@ -3,8 +3,10 @@
 `boat` - A **B**asic **O**pinionated **A**ctivity **T**racker, inspired by [bartib](https://github.com/nikolassv/bartib).
 
 Like its name implies, `boat` allows you to track the time you spend on everyday tasks.
+
 It has mainly been designed to be easy to embed in custom bash scripts so that you can augment it with fuzzy-finding.
-That said, if you plan to use the CLI directly (without external scripts), it also benefits from a [variety of handy aliases](#usage).
+That said, if you plan to use the CLI directly (without external scripts), it also benefits from a [variety of handy aliases](#-usage).
+
 `boat` stores its data in a SQLite database file which is kept in the config directory by default (`.config/boat/boat.db`).
 
 This repository contains only the code for the command line application.

README.md

@@ -34,6 +34,31 @@ impl PrintableActivity {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn tags_str_renders_comma_separated() {
+        let mut tags = HashSet::new();
+        tags.insert("foo".to_owned());
+        tags.insert("bar".to_owned());
+
+        let act = PrintableActivity {
+            id: 42,
+            name: "n".to_owned(),
+            description: None,
+            ongoing: false,
+            tags,
+        };
+        let tags_str = act.tags_str();
+
+        assert!(tags_str.contains("foo"));
+        assert!(tags_str.contains("bar"));
+        assert!(tags_str.find(',').is_some());
+    }
+}
+
 impl RowPrintable for PrintableActivity {
     fn row_spec() -> String {
         "{:>}  {:<}  {:<}  {:<}  {:^}".to_string()

src/models/activity.rs

@@ -15,9 +15,29 @@ impl PrintableLog {
             ends_at: log.ends_at.map(|t| t.with_timezone(&Local)),
         }
     }
-
     pub fn duration_sec(&self) -> i64 {
         let end = self.ends_at.unwrap_or(Local::now());
         (end - self.starts_at).num_seconds()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_duration_sec() {
+        let now = Local::now();
+        let log = PrintableLog {
+            starts_at: now,
+            ends_at: Some(now + chrono::Duration::seconds(60)),
+        };
+        assert_eq!(log.duration_sec(), 60);
+
+        let log = PrintableLog {
+            starts_at: now,
+            ends_at: None,
+        };
+        assert!(log.duration_sec() >= 0); // Should not panic
+    }
+}

src/models/log.rs

@@ -19,6 +19,21 @@ impl PrintableTag {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn parse_from_tag_works() {
+        let db_tag = DatabaseTag {
+            id: 1,
+            name: "foo".to_string(),
+        };
+        let tag = PrintableTag::from_tag(&db_tag);
+        assert_eq!(tag.id, 1);
+        assert_eq!(tag.name, "foo");
+    }
+}
+
 impl RowPrintable for PrintableTag {
     fn row_spec() -> String {
         "{:>}  {:<}".to_string()

src/models/tag.rs

@@ -13,17 +13,33 @@ pub fn pretty_format_duration(mut seconds: i64) -> String {
         parts.push(format!("{hours}h"));
     }
 
-    if minutes > 0 || hours > 0 {
+    if minutes > 0 {
         parts.push(format!("{minutes}m"));
     }
 
-    if parts.len() < 2 && (seconds > 0 || parts.is_empty()) {
+    if hours == 0 && minutes == 0 {
         parts.push(format!("{seconds}s"));
     }
 
     parts.join(" ")
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_pretty_format_duration() {
+        assert_eq!(&pretty_format_duration(0), "0s");
+        assert_eq!(&pretty_format_duration(42), "42s");
+        assert_eq!(&pretty_format_duration(60), "1m");
+        assert_eq!(&pretty_format_duration(61), "1m");
+        assert_eq!(&pretty_format_duration(3600), "1h");
+        assert_eq!(&pretty_format_duration(3601), "1h");
+        assert_eq!(&pretty_format_duration(3661), "1h 1m");
+    }
+}
+
 pub enum DateTimeRenderMode {
     TimeOnly,
     DateOnly,
@@ -151,3 +167,21 @@ pub fn parse_date(s: &str) -> Result<NaiveDate, String> {
     NaiveDate::parse_from_str(s, "%Y-%m-%d")
         .map_err(|_| format!("invalid date '{s}', expected format YYYY-MM-DD"))
 }
+
+#[cfg(test)]
+mod parse_date_tests {
+    use super::*;
+
+    #[test]
+    fn parse_date_valid_should_succeed() {
+        assert_eq!(
+            parse_date("2023-08-14").unwrap(),
+            NaiveDate::from_ymd_opt(2023, 8, 14).unwrap()
+        );
+    }
+    #[test]
+    fn parse_date_fails_invalid_should_fail() {
+        let e = parse_date("nope").unwrap_err();
+        assert!(e.contains("invalid date"));
+    }
+}

src/utils/date.rs

@@ -0,0 +1,51 @@
+//! Test basic activity CRUD and flow in the CLI
+use assert_cmd::Command;
+use predicates::prelude::*;
+use std::fs;
+use tempfile::TempDir;
+
+/// Helper to spin up a temp config + db directory and return required CLI args
+fn cli_args_for_temp() -> (TempDir, String) {
+    let tmp = TempDir::new().unwrap();
+    let db_path = tmp.path().join("boat.db");
+    let config_path = tmp.path().join("boat_config.toml");
+    fs::write(
+        &config_path,
+        format!("database_path = {:?}", db_path.display()),
+    )
+    .unwrap();
+    (tmp, config_path.display().to_string())
+}
+
+#[test]
+fn can_create_start_pause_list_activity() {
+    let (_tmp, config_path) = cli_args_for_temp();
+
+    // boat new
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.env("BOAT_CONFIG", &config_path)
+        .arg("new")
+        .arg("TestTask");
+    cmd.assert().success();
+
+    // boat start <ID: always 1 for first activity>
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.env("BOAT_CONFIG", &config_path).arg("start").arg("1");
+    cmd.assert().success();
+
+    // boat pause
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.env("BOAT_CONFIG", &config_path).arg("pause");
+    cmd.assert().success().stdout(
+        predicates::str::contains("stopped").or(predicates::str::contains("stopped activity")),
+    );
+
+    // boat list --json, just check output contains the activity name 'TestTask'
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.env("BOAT_CONFIG", &config_path)
+        .arg("list")
+        .arg("--json");
+    cmd.assert()
+        .success()
+        .stdout(predicates::str::contains("TestTask"));
+}

tests/cli_activity_flow.rs

@@ -0,0 +1,59 @@
+//! Tests for error/failure scenarios in the CLI
+use assert_cmd::Command;
+use predicates::prelude::*;
+use std::fs;
+use tempfile::TempDir;
+
+fn cli_args_for_temp() -> (TempDir, String) {
+    let tmp = TempDir::new().unwrap();
+    let db_path = tmp.path().join("boat.db");
+    let config_path = tmp.path().join("boat_config.toml");
+    fs::write(
+        &config_path,
+        format!("database_path = {:?}", db_path.display()),
+    )
+    .unwrap();
+    (tmp, config_path.display().to_string())
+}
+
+#[test]
+fn new_without_name_should_fail() {
+    let (_tmp, config_path) = cli_args_for_temp();
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.env("BOAT_CONFIG", &config_path).arg("new");
+
+    // purposely omit activity name
+    cmd.assert().failure().stderr(
+        predicates::str::contains("error").or(predicates::str::contains("required arguments")),
+    );
+}
+
+#[test]
+fn list_mutually_exclusive_args_should_fail() {
+    let (_tmp, config_path) = cli_args_for_temp();
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+
+    cmd.env("BOAT_CONFIG", &config_path)
+        .arg("list")
+        .arg("--period")
+        .arg("today")
+        .arg("--date")
+        .arg("2024-05-01");
+    cmd.assert()
+        .failure()
+        .stderr(predicates::str::contains("cannot be used with"));
+}
+
+#[test]
+fn list_with_invalid_date_input_should_fail() {
+    let (_tmp, config_path) = cli_args_for_temp();
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+
+    cmd.env("BOAT_CONFIG", &config_path)
+        .arg("list")
+        .arg("--date")
+        .arg("not-a-date");
+    cmd.assert()
+        .failure()
+        .stderr(predicates::str::contains("invalid date"));
+}

tests/cli_errors.rs

@@ -0,0 +1,39 @@
+//! Basic smoke tests: help, version, invalid command
+use assert_cmd::Command;
+use predicates::prelude::PredicateBooleanExt;
+
+#[test]
+fn test_help_arg() {
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.arg("--help");
+    cmd.assert()
+        .success()
+        .stdout(predicates::str::contains("Usage").or(predicates::str::contains("USAGE")));
+}
+
+#[test]
+fn test_help_subcommand_short_alias() {
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.arg("h");
+    cmd.assert()
+        .success()
+        .stdout(predicates::str::contains("Usage").or(predicates::str::contains("USAGE")));
+}
+
+#[test]
+fn test_version_arg() {
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.arg("--version");
+    cmd.assert()
+        .success()
+        .stdout(predicates::str::contains("boat"));
+}
+
+#[test]
+fn test_unknown_subcommand_fails() {
+    let mut cmd = Command::cargo_bin("boat").unwrap();
+    cmd.arg("definitely-not-a-command");
+    cmd.assert().failure().stderr(
+        predicates::str::contains("error").or(predicates::str::contains("not a valid subcommand")),
+    );
+}