Shanty/watch
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updates for the "full flow"

Browse Source
This commit is contained in:
Connor Johnstone
2026-03-17 21:39:24 -04:00
parent d754f21841
commit 7bee8a9afa
4 changed files with 319 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

186
tests/integration.rs
View File

@@ -3,7 +3,8 @@ use sea_orm::ActiveValue::Set;
use shanty_db::entities::wanted_item::{ItemType, WantedStatus};
use shanty_db::{Database, queries};
use shanty_tag::MusicBrainzClient;
use shanty_tag::error::TagResult;
use shanty_tag::provider::*;
use shanty_watch::{add_album, add_artist, add_track, library_summary, list_items, remove_item};
async fn test_db() -> Database {
@@ -37,58 +38,72 @@ async fn insert_track(db: &Database, artist: &str, title: &str, album: &str) {
queries::tracks::upsert(db.conn(), active).await.unwrap();
}
// No MB client needed for tests — pass None
const NO_MB: Option<&MusicBrainzClient> = None;
/// Mock provider that returns a tracklist for known releases.
struct MockProvider;
#[tokio::test]
async fn test_add_artist_wanted() {
let db = test_db().await;
let entry = add_artist(db.conn(), Some("Radiohead"), None, NO_MB).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;
insert_track(&db, "Pink Floyd", "Time", "DSOTM").await;
let entry = add_artist(db.conn(), Some("Pink Floyd"), None, NO_MB).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(), Some("Radiohead"), Some("OK Computer"), None, NO_MB)
.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(), Some("Pink Floyd"), Some("DSOTM"), None, NO_MB)
.await
.unwrap();
assert_eq!(entry.status, WantedStatus::Owned);
impl MetadataProvider for MockProvider {
async fn search_recording(&self, _artist: &str, _title: &str) -> TagResult<Vec<RecordingMatch>> {
Ok(vec![])
}
async fn search_release(&self, _artist: &str, _album: &str) -> TagResult<Vec<ReleaseMatch>> {
Ok(vec![ReleaseMatch {
mbid: "release-123".into(),
title: "Test Album".into(),
artist: "Test Artist".into(),
artist_mbid: Some("artist-456".into()),
date: Some("2024".into()),
track_count: Some(2),
score: 100,
}])
}
async fn get_recording(&self, _mbid: &str) -> TagResult<RecordingDetails> {
Err(shanty_tag::TagError::Other("not found".into()))
}
async fn search_artist(&self, _query: &str, _limit: u32) -> TagResult<Vec<ArtistSearchResult>> {
Ok(vec![ArtistSearchResult {
mbid: "artist-456".into(),
name: "Test Artist".into(),
disambiguation: None,
country: None,
artist_type: None,
score: 100,
}])
}
async fn get_artist_releases(&self, _mbid: &str, _limit: u32) -> TagResult<Vec<DiscographyEntry>> {
Ok(vec![DiscographyEntry {
mbid: "release-123".into(),
title: "Test Album".into(),
date: Some("2024".into()),
release_type: Some("Album".into()),
track_count: Some(2),
}])
}
async fn get_release_tracks(&self, _release_mbid: &str) -> TagResult<Vec<ReleaseTrack>> {
Ok(vec![
ReleaseTrack {
recording_mbid: "rec-1".into(),
title: "Track One".into(),
track_number: Some(1),
disc_number: Some(1),
duration_ms: Some(180_000),
},
ReleaseTrack {
recording_mbid: "rec-2".into(),
title: "Track Two".into(),
track_number: Some(2),
disc_number: Some(1),
duration_ms: Some(200_000),
},
])
}
}
#[tokio::test]
async fn test_add_track_wanted() {
let db = test_db().await;
let provider = MockProvider;
let entry = add_track(db.conn(), Some("Radiohead"), Some("Creep"), None, NO_MB)
let entry = add_track(db.conn(), Some("Radiohead"), Some("Creep"), None, &provider)
.await
.unwrap();
assert_eq!(entry.item_type, ItemType::Track);
@@ -99,53 +114,81 @@ async fn test_add_track_wanted() {
#[tokio::test]
async fn test_add_track_auto_owned() {
let db = test_db().await;
let provider = MockProvider;
insert_track(&db, "Pink Floyd", "Time", "DSOTM").await;
let entry = add_track(db.conn(), Some("Pink Floyd"), Some("Time"), None, NO_MB)
let entry = add_track(db.conn(), Some("Pink Floyd"), Some("Time"), None, &provider)
.await
.unwrap();
assert_eq!(entry.status, WantedStatus::Owned);
}
#[tokio::test]
async fn test_add_album_expands_to_tracks() {
let db = test_db().await;
let provider = MockProvider;
let summary = add_album(db.conn(), Some("Test Artist"), Some("Test Album"), None, &provider)
.await
.unwrap();
assert_eq!(summary.tracks_added, 2);
let items = list_items(db.conn(), Some(WantedStatus::Wanted), None)
.await
.unwrap();
assert_eq!(items.len(), 2);
assert_eq!(items[0].item_type, ItemType::Track);
}
#[tokio::test]
async fn test_add_artist_expands_to_tracks() {
let db = test_db().await;
let provider = MockProvider;
let summary = add_artist(db.conn(), Some("Test Artist"), None, &provider)
.await
.unwrap();
assert_eq!(summary.tracks_added, 2);
let items = list_items(db.conn(), None, None).await.unwrap();
assert_eq!(items.len(), 2);
}
#[tokio::test]
async fn test_list_items_with_filters() {
let db = test_db().await;
let provider = MockProvider;
add_artist(db.conn(), Some("Radiohead"), None, NO_MB).await.unwrap();
add_artist(db.conn(), Some("Tool"), None, NO_MB).await.unwrap();
add_track(db.conn(), Some("Radiohead"), Some("Creep"), None, &provider)
.await
.unwrap();
add_track(db.conn(), Some("Tool"), Some("Lateralus"), None, &provider)
.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 provider = MockProvider;
let entry = add_artist(db.conn(), Some("Radiohead"), None, NO_MB).await.unwrap();
let all = list_items(db.conn(), None, None).await.unwrap();
assert_eq!(all.len(), 1);
let entry = add_track(db.conn(), Some("Radiohead"), Some("Creep"), None, &provider)
.await
.unwrap();
remove_item(db.conn(), entry.id).await.unwrap();
let all = list_items(db.conn(), None, None).await.unwrap();
assert!(all.is_empty());
@@ -154,18 +197,19 @@ async fn test_remove_item() {
#[tokio::test]
async fn test_library_summary() {
let db = test_db().await;
let provider = MockProvider;
insert_track(&db, "Pink Floyd", "Time", "DSOTM").await;
add_artist(db.conn(), Some("Radiohead"), None, NO_MB).await.unwrap();
add_artist(db.conn(), Some("Pink Floyd"), None, NO_MB).await.unwrap();
add_album(db.conn(), Some("Tool"), Some("Lateralus"), None, NO_MB).await.unwrap();
add_track(db.conn(), Some("Pink Floyd"), Some("Time"), None, NO_MB).await.unwrap();
add_track(db.conn(), Some("Radiohead"), Some("Creep"), None, &provider)
.await
.unwrap();
add_track(db.conn(), Some("Pink Floyd"), Some("Time"), None, &provider)
.await
.unwrap();
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);
assert_eq!(summary.total_items, 2);
assert_eq!(summary.wanted, 1);
assert_eq!(summary.owned, 1);
}