mpdclient 0.2.0

use mpdclient::ConsumeState;
use mpdclient::{AudioFormat, Channels, SingleState, State, SupportedBits};

use crate::common::setup_mpd;

mod common;

#[test]
fn volume() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert_eq!(conn.status()?.volume(), Some(100));
            Ok(())
        },
    )
}

#[test]
fn repeat() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert!(!conn.status()?.repeat());
            Ok(())
        },
    )
}

#[test]
fn random() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert!(!conn.status()?.random());
            Ok(())
        },
    )
}

#[test]
fn single_state() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert_eq!(conn.status()?.single_state(), SingleState::Off);
            Ok(())
        },
    )
}

#[test]
fn consume_state() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert_eq!(conn.status()?.consume_state(), ConsumeState::Off);
            Ok(())
        },
    )
}

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

            assert_eq!(
                conn.status()?.queue_length() as usize,
                conn.queue().list()?.len()
            );
            Ok(())
        },
    )
}

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

            assert_eq!(conn.status()?.queue_version(), 3);
            Ok(())
        },
    )
}

#[test]
fn state_stop() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert_eq!(conn.status()?.state(), State::Stop);
            Ok(())
        },
    )
}

#[test]
fn state_play() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;
            conn.player().play()?;
            assert_eq!(conn.status()?.state(), State::Play);
            Ok(())
        },
    )
}

#[test]
fn state_pause() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;
            assert_eq!(conn.status()?.state(), State::Pause);
            Ok(())
        },
    )
}

#[test]
fn crossfade() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert!(conn.status()?.crossfade().is_none());
            Ok(())
        },
    )
}

#[test]
fn mixrampdb() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert!(conn.status()?.mixrampdb().is_none());
            Ok(())
        },
    )
}

#[test]
fn mixrampdelay() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert!(conn.status()?.mixrampdelay().is_none());
            Ok(())
        },
    )
}

#[test]
fn current_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")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            assert_eq!(conn.status()?.current_song_pos(), Some(0));
            Ok(())
        },
    )
}

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

            assert_eq!(conn.status()?.current_song_id(), Some(id));
            Ok(())
        },
    )
}

#[test]
fn next_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")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            assert_eq!(conn.status()?.next_song_pos(), Some(1));
            Ok(())
        },
    )
}

#[test]
fn next_song_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")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            assert_eq!(conn.status()?.next_song_id(), Some(id));
            Ok(())
        },
    )
}

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

            assert_eq!(conn.status()?.elapsed_ms(), 2000);
            Ok(())
        },
    )
}

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

            assert_eq!(conn.status()?.total_time(), 30);
            Ok(())
        },
    )
}

#[test]
fn kbit_rate() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song_copy("song"),
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            conn.player().play()?;
            std::thread::sleep(std::time::Duration::from_millis(10));
            conn.player().pause(true)?;

            assert_eq!(conn.status()?.kbit_rate(), Some(8));
            Ok(())
        },
    )
}

#[test]
fn audio_format() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song_copy("song"),
        |conn| {
            let queue = conn.queue();
            queue.add("song.mp3")?;
            conn.player().play()?;
            std::thread::sleep(std::time::Duration::from_millis(10));
            conn.player().pause(true)?;

            assert_eq!(
                conn.status()?.audio_format(),
                Some(AudioFormat {
                    sample_rate: Some(8000),
                    bits: SupportedBits::N16,
                    channels: Channels::Mono
                })
            );
            Ok(())
        },
    )
}

#[test]
fn update() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert!(!conn.status()?.update());
            Ok(())
        },
    )
}

#[test]
fn partition() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            assert_eq!(conn.status()?.partition(), Some("default".to_string()));
            Ok(())
        },
    )
}