mpdclient 0.2.0

use mpdclient::{Position, Song, Tag, connection::queue::Change};

use crate::common::setup_mpd;

mod common;

#[test]
fn list() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;

            let queue = queue.list()?;
            assert_eq!(queue.len(), 3);
            Ok(())
        },
    )
}

#[test]
fn list_range() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            let queue_range = queue.list_range(1, Some(3))?;
            assert_eq!(queue_range.len(), 2);
            for (i, s) in queue_range.iter().enumerate() {
                if i == 0 {
                    assert_eq!(s.uri(), "song2.mp3");
                } else {
                    assert_eq!(s.uri(), "song.mp3");
                }
            }
            Ok(())
        },
    )
}

#[test]
fn list_range_end() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            let queue_range = queue.list_range(2, None)?;
            assert_eq!(queue_range.len(), 2);
            Ok(())
        },
    )
}

#[test]
fn get_song_pos() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            let song = queue.get_song_pos(0)?;
            assert_eq!(song.uri(), "song.mp3");
            let song = queue.get_song_pos(1)?;
            assert_eq!(song.uri(), "song2.mp3");
            Ok(())
        },
    )
}

#[test]
fn get_song_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            let song = queue.get_song_id(1)?;
            assert_eq!(song.uri(), "song.mp3");
            let song = queue.get_song_id(2)?;
            assert_eq!(song.uri(), "song2.mp3");
            Ok(())
        },
    )
}

#[test]
fn changes_meta() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            let ver = conn.status()?.queue_version();
            queue.add_position("song.mp3", 1, Position::Absolute)?;

            assert_eq!(queue.changes_meta(ver)?.first().unwrap().uri(), "song.mp3");
            Ok(())
        },
    )
}

#[test]
fn changes_meta_range() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            let ver = conn.status()?.queue_version();
            queue.add_position("song2.mp3", 1, Position::Absolute)?;
            queue.add_position("song.mp3", 2, Position::Absolute)?;

            assert_eq!(
                queue
                    .changes_meta_range(ver, 1, Some(3))?
                    .iter()
                    .map(Song::uri)
                    .collect::<Vec<String>>(),
                vec!["song2.mp3", "song.mp3"]
            );

            Ok(())
        },
    )
}

#[test]
fn changes() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            let ver = conn.status()?.queue_version();
            let id = queue.add_id_position("song.mp3", 1, Position::Absolute)?;

            assert_eq!(queue.changes(ver)?.next(), Some(Change { position: 1, id }));
            Ok(())
        },
    )
}

#[test]
fn changes_range() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            let ver = conn.status()?.queue_version();
            let id = queue.add_id_position("song.mp3", 1, Position::Absolute)?;
            let id2 = queue.add_id_position("song2.mp3", 2, Position::Absolute)?;

            let mut changes = queue.changes_range(ver, 1, Some(3))?;
            assert_eq!(changes.next(), Some(Change { position: 1, id }));
            assert_eq!(
                changes.next(),
                Some(Change {
                    position: 2,
                    id: id2
                })
            );
            assert_eq!(changes.next(), None);
            Ok(())
        },
    )
}

// --- Manipulation ---

#[test]
fn add() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song2.mp3")?;

            queue.add("song.mp3")?;
            assert_eq!(queue.list()?.last().unwrap().uri(), "song.mp3");
            Ok(())
        },
    )
}

#[test]
fn add_http() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song2.mp3")?;

            queue.add("http://localhost:6601/song.mp3")?;
            assert_eq!(
                queue.list()?.last().unwrap().uri(),
                "http://localhost:6601/song.mp3"
            );
            Ok(())
        },
    )
}

#[test]
fn add_whence_absolute() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            queue.add_position("song.mp3", 1, Position::Absolute)?;
            assert_eq!(queue.list()?[1].uri(), "song.mp3");
            Ok(())
        },
    )
}

#[test]
fn add_whence_before_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            queue.add_position("song2.mp3", 0, Position::BeforeCurrent)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song2.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn add_whence_after_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            queue.add_position("song2.mp3", 0, Position::AfterCurrent)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song2.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn add_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            let id = queue.add_id("song.mp3")?;
            assert_eq!(
                queue.get_song_id(id)?.uri(),
                queue.list()?.last().unwrap().uri()
            );
            assert_eq!(queue.get_song_id(id)?.uri(), "song.mp3");
            Ok(())
        },
    )
}

#[test]
fn add_id_whence_absolute() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            let id = queue.add_id_position("song.mp3", 1, Position::Absolute)?;
            assert_eq!(queue.get_song_id(id)?.uri(), "song.mp3");
            assert_eq!(queue.get_song_pos(1)?.uri(), "song.mp3");
            Ok(())
        },
    )
}

#[test]
fn add_id_whence_before_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            let id = queue.add_id_position("song2.mp3", 0, Position::BeforeCurrent)?;
            assert_eq!(queue.get_song_id(id)?.uri(), "song2.mp3");
            assert_eq!(queue.get_song_pos(0)?.uri(), "song2.mp3");
            Ok(())
        },
    )
}

#[test]
fn add_id_whence_after_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            let id = queue.add_id_position("song.mp3", 0, Position::AfterCurrent)?;
            assert_eq!(queue.get_song_id(id)?.uri(), "song.mp3");
            assert_eq!(queue.get_song_pos(1)?.uri(), "song.mp3");
            Ok(())
        },
    )
}

#[test]
fn delete() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            queue.delete(0)?;
            assert_eq!(queue.get_song_pos(0)?.uri(), "song2.mp3");
            Ok(())
        },
    )
}

#[test]
fn delete_range() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;

            queue.delete_range(1, Some(3))?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn delete_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            let id = queue.add_id("song2.mp3")?;
            queue.add("song.mp3")?;

            queue.delete_id(id)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn shuffle() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            for i in 0..1000 {
                setup.song(&format!("song{i}"))?;
            }
            Ok(())
        },
        |conn| {
            let queue = conn.queue();
            let mut orig = Vec::new();
            for i in 0..1000 {
                let uri = format!("song{i}.mp3");
                queue.add(&uri)?;
                orig.push(uri);
            }

            queue.shuffle()?;
            assert_ne!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                orig
            );
            Ok(())
        },
    )
}

#[test]
fn shuffle_range() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            for i in 0..2000 {
                setup.song(&format!("song{i}"))?;
            }
            Ok(())
        },
        |conn| {
            let queue = conn.queue();
            let mut orig = Vec::new();
            for i in 0..2000 {
                let uri = format!("song{i}.mp3");
                queue.add(&uri)?;
                orig.push(uri);
            }

            queue.shuffle_range(1000, None)?;
            assert_eq!(
                queue
                    .list_range(0, Some(1000))?
                    .iter()
                    .map(Song::uri)
                    .collect::<Vec<String>>(),
                orig.split_at(1000).0
            );
            assert_ne!(
                queue
                    .list_range(1000, None)?
                    .iter()
                    .map(Song::uri)
                    .collect::<Vec<String>>(),
                orig.split_at(1000).1
            );
            Ok(())
        },
    )
}

#[test]
fn clear() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;

            queue.clear()?;
            assert_eq!(queue.list()?.len(), 0);
            Ok(())
        },
    )
}

#[test]
fn move_pos() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;

            queue.move_pos(1, 2)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_whence_absolute() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;

            queue.move_whence(1, 2, Position::Absolute)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_whence_after_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            queue.move_whence(2, 0, Position::AfterCurrent)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_whence_before_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            queue.move_whence(1, 0, Position::BeforeCurrent)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song2.mp3", "song.mp3", "song.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            let id = queue.add_id("song2.mp3")?;
            queue.add("song.mp3")?;

            queue.move_id(id, 2)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_id_whence_absolute() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            let id = queue.add_id("song2.mp3")?;
            queue.add("song.mp3")?;

            queue.move_id_whence(id, 2, Position::Absolute)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_id_whence_after_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            let id = queue.add_id("song.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            queue.move_id_whence(id, 0, Position::AfterCurrent)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_id_whence_before_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            let id = queue.add_id("song2.mp3")?;
            queue.add("song.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            queue.move_id_whence(id, 0, Position::BeforeCurrent)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song2.mp3", "song.mp3", "song.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_range() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song2.mp3")?;

            queue.move_range(1, 3, 0)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song2.mp3", "song2.mp3", "song.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_range_whence_absolute() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song2.mp3")?;

            queue.move_range_whence(1, 3, 0, Position::Absolute)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song2.mp3", "song2.mp3", "song.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_range_whence_after_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            queue.move_range_whence(2, 4, 0, Position::AfterCurrent)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3", "song2.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn move_range_whence_before_current() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            queue.move_range_whence(2, 4, 0, Position::BeforeCurrent)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song2.mp3", "song.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn swap() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song2.mp3")?;
            queue.add("song2.mp3")?;

            queue.swap(0, 1)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song2.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn swap_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            let id1 = queue.add_id("song2.mp3")?;
            let id2 = queue.add_id("song.mp3")?;

            queue.swap_id(id1, id2)?;
            assert_eq!(
                queue.list()?.iter().map(Song::uri).collect::<Vec<String>>(),
                vec!["song.mp3", "song.mp3", "song2.mp3"]
            );
            Ok(())
        },
    )
}

#[test]
fn add_tag_id() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            let queue = conn.queue();
            let id = queue.add_id("http://localhost:6601/song.mp3")?;

            queue.add_tag_id(id, Tag::Name, "add_tag_id")?;
            assert_eq!(
                queue.get_song_id(id)?.tag(Tag::Name).receive_all(),
                vec!["add_tag_id"]
            );

            Ok(())
        },
    )
}

#[test]
fn clear_tag_id() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            let queue = conn.queue();
            let id = queue.add_id("http://localhost:6601/song.mp3")?;

            queue.add_tag_id(id, Tag::Name, "add_tag_id")?;
            queue.clear_tag_id(id, Tag::Name)?;

            assert!(
                queue
                    .get_song_id(id)?
                    .tag(Tag::Name)
                    .receive_all()
                    .is_empty()
            );

            Ok(())
        },
    )
}

#[test]
fn clear_all_tags_id() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            let queue = conn.queue();
            let id = queue.add_id("http://localhost:6601/song.mp3")?;

            queue.add_tag_id(id, Tag::Name, "add_tag_id")?;
            queue.add_tag_id(id, Tag::Name, "add_tag_id2")?;
            queue.add_tag_id(id, Tag::Disc, "2")?;
            queue.clear_all_tags_id(id)?;

            assert!(
                queue
                    .get_song_id(id)?
                    .tag(Tag::Name)
                    .receive_all()
                    .is_empty()
            );
            assert!(
                queue
                    .get_song_id(id)?
                    .tag(Tag::Disc)
                    .receive_all()
                    .is_empty()
            );

            Ok(())
        },
    )
}

#[test]
fn priority() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;

            queue.priority(100, 0)?;
            assert_eq!(queue.get_song_pos(0)?.prio(), 100);
            Ok(())
        },
    )
}

#[test]
fn priority_range() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            queue.add("song.mp3")?;
            queue.add("song.mp3")?;

            queue.priority_range(100, 1, None)?;
            assert_eq!(queue.get_song_pos(0)?.prio(), 0);
            assert_eq!(queue.get_song_pos(1)?.prio(), 100);
            assert_eq!(queue.get_song_pos(2)?.prio(), 100);
            Ok(())
        },
    )
}

#[test]
fn priority_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            let queue = conn.queue();
            let id = queue.add_id("song.mp3")?;

            queue.priority_id(100, id)?;
            assert_eq!(queue.get_song_id(id)?.prio(), 100);
            Ok(())
        },
    )
}

#[test]
fn range_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            let queue = conn.queue();
            let id = queue.add_id("song.mp3")?;

            queue.range_id(id, 1.0, Some(10.0))?;
            assert_eq!(queue.get_song_id(id)?.start(), 1);
            assert_eq!(queue.get_song_id(id)?.end(), Some(10));
            Ok(())
        },
    )
}

#[test]
fn range_id_open() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            let queue = conn.queue();
            let id = queue.add_id("song.mp3")?;

            queue.range_id(id, 1.0, None)?;
            assert_eq!(queue.get_song_id(id)?.start(), 1);
            assert_eq!(queue.get_song_id(id)?.end(), None);
            Ok(())
        },
    )
}