Initial commit

tests/integration.rs

@@ -0,0 +1,169 @@
+use chrono::Utc;
+use sea_orm::ActiveValue::Set;
+
+use shanty_db::entities::wanted_item::{ItemType, WantedStatus};
+use shanty_db::{Database, queries};
+use shanty_watch::{add_album, add_artist, add_track, library_summary, list_items, remove_item};
+
+async fn test_db() -> Database {
+    Database::new("sqlite::memory:")
+        .await
+        .expect("failed to create test database")
+}
+
+/// Insert a fake track into the DB to simulate an indexed library.
+async fn insert_track(db: &Database, artist: &str, title: &str, album: &str) {
+    let now = Utc::now().naive_utc();
+    let artist_rec = queries::artists::upsert(db.conn(), artist, None)
+        .await
+        .unwrap();
+    let album_rec = queries::albums::upsert(db.conn(), album, artist, None, Some(artist_rec.id))
+        .await
+        .unwrap();
+    let active = shanty_db::entities::track::ActiveModel {
+        file_path: Set(format!("/music/{artist}/{album}/{title}.mp3")),
+        title: Set(Some(title.to_string())),
+        artist: Set(Some(artist.to_string())),
+        album: Set(Some(album.to_string())),
+        album_artist: Set(Some(artist.to_string())),
+        file_size: Set(1_000_000),
+        artist_id: Set(Some(artist_rec.id)),
+        album_id: Set(Some(album_rec.id)),
+        added_at: Set(now),
+        updated_at: Set(now),
+        ..Default::default()
+    };
+    queries::tracks::upsert(db.conn(), active).await.unwrap();
+}
+
+#[tokio::test]
+async fn test_add_artist_wanted() {
+    let db = test_db().await;
+
+    let entry = add_artist(db.conn(), "Radiohead", None).await.unwrap();
+    assert_eq!(entry.item_type, ItemType::Artist);
+    assert_eq!(entry.name, "Radiohead");
+    assert_eq!(entry.status, WantedStatus::Wanted);
+}
+
+#[tokio::test]
+async fn test_add_artist_auto_owned() {
+    let db = test_db().await;
+
+    // Index some tracks first
+    insert_track(&db, "Pink Floyd", "Time", "DSOTM").await;
+
+    // Add artist to watchlist — should auto-detect as owned
+    let entry = add_artist(db.conn(), "Pink Floyd", None).await.unwrap();
+    assert_eq!(entry.status, WantedStatus::Owned);
+}
+
+#[tokio::test]
+async fn test_add_album_wanted() {
+    let db = test_db().await;
+
+    let entry = add_album(db.conn(), "Radiohead", "OK Computer", None)
+        .await
+        .unwrap();
+    assert_eq!(entry.item_type, ItemType::Album);
+    assert_eq!(entry.name, "OK Computer");
+    assert_eq!(entry.status, WantedStatus::Wanted);
+}
+
+#[tokio::test]
+async fn test_add_album_auto_owned() {
+    let db = test_db().await;
+
+    insert_track(&db, "Pink Floyd", "Time", "DSOTM").await;
+
+    let entry = add_album(db.conn(), "Pink Floyd", "DSOTM", None)
+        .await
+        .unwrap();
+    assert_eq!(entry.status, WantedStatus::Owned);
+}
+
+#[tokio::test]
+async fn test_add_track_wanted() {
+    let db = test_db().await;
+
+    let entry = add_track(db.conn(), "Radiohead", "Creep", None)
+        .await
+        .unwrap();
+    assert_eq!(entry.item_type, ItemType::Track);
+    assert_eq!(entry.name, "Creep");
+    assert_eq!(entry.status, WantedStatus::Wanted);
+}
+
+#[tokio::test]
+async fn test_add_track_auto_owned() {
+    let db = test_db().await;
+
+    insert_track(&db, "Pink Floyd", "Time", "DSOTM").await;
+
+    let entry = add_track(db.conn(), "Pink Floyd", "Time", None)
+        .await
+        .unwrap();
+    assert_eq!(entry.status, WantedStatus::Owned);
+}
+
+#[tokio::test]
+async fn test_list_items_with_filters() {
+    let db = test_db().await;
+
+    add_artist(db.conn(), "Radiohead", None).await.unwrap();
+    add_artist(db.conn(), "Tool", None).await.unwrap();
+
+    // List all
+    let all = list_items(db.conn(), None, None).await.unwrap();
+    assert_eq!(all.len(), 2);
+
+    // List by status
+    let wanted = list_items(db.conn(), Some(WantedStatus::Wanted), None)
+        .await
+        .unwrap();
+    assert_eq!(wanted.len(), 2);
+
+    let owned = list_items(db.conn(), Some(WantedStatus::Owned), None)
+        .await
+        .unwrap();
+    assert!(owned.is_empty());
+
+    // List by artist
+    let radiohead = list_items(db.conn(), None, Some("Radiohead"))
+        .await
+        .unwrap();
+    assert_eq!(radiohead.len(), 1);
+    assert_eq!(radiohead[0].name, "Radiohead");
+}
+
+#[tokio::test]
+async fn test_remove_item() {
+    let db = test_db().await;
+
+    let entry = add_artist(db.conn(), "Radiohead", None).await.unwrap();
+    let all = list_items(db.conn(), None, None).await.unwrap();
+    assert_eq!(all.len(), 1);
+
+    remove_item(db.conn(), entry.id).await.unwrap();
+    let all = list_items(db.conn(), None, None).await.unwrap();
+    assert!(all.is_empty());
+}
+
+#[tokio::test]
+async fn test_library_summary() {
+    let db = test_db().await;
+
+    insert_track(&db, "Pink Floyd", "Time", "DSOTM").await;
+
+    add_artist(db.conn(), "Radiohead", None).await.unwrap(); // wanted
+    add_artist(db.conn(), "Pink Floyd", None).await.unwrap(); // owned
+    add_album(db.conn(), "Tool", "Lateralus", None).await.unwrap(); // wanted
+    add_track(db.conn(), "Pink Floyd", "Time", None).await.unwrap(); // owned
+
+    let summary = library_summary(db.conn()).await.unwrap();
+    assert_eq!(summary.total_artists, 2);
+    assert_eq!(summary.total_albums, 1);
+    assert_eq!(summary.total_tracks, 1);
+    assert_eq!(summary.wanted, 2);
+    assert_eq!(summary.owned, 2);
+}