//! Tests for `bxctl memory tiers`. Do not edit.

#[path = "support/temp.rs"]
mod temp;
use std::os::unix::net::UnixListener;
use std::path::{Path, PathBuf};
use std::sync::mpsc;
use std::time::Duration;

use bxcore::{Envelope, MemoryAdminReply, MemoryCommand, Message, read_frame, write_frame};
use bxctl::cli::{Command, UsageError, parse};
use bxctl::memory::{Ask, run};

fn args(line: &str) -> Vec<String> {
    line.split_whitespace().map(str::to_string).collect()
}

fn home() -> PathBuf {
    PathBuf::from("/srv/bx")
}

fn fake(socket: &Path, answer: Message) -> mpsc::Receiver<Message> {
    let listener = UnixListener::bind(socket).unwrap();
    let (tx, rx) = mpsc::channel();
    std::thread::spawn(move || {
        let (mut stream, _) = listener.accept().unwrap();
        let env = read_frame(&mut stream).unwrap();
        tx.send(env.msg).unwrap();
        let reply = Envelope {
            v: 1,
            id: env.id,
            r#final: true,
            msg: answer,
        };
        write_frame(&mut stream, &reply).unwrap();
    });
    rx
}

#[test]
fn memory_tiers_parses() {
    let h = home();
    assert_eq!(
        parse(&args("memory tiers"), &h),
        Ok(Command::Memory {
            socket: PathBuf::from("/srv/bx/run/owner-memory/admin.sock"),
            ask: Ask::Admin(MemoryCommand::Tiers, String::new())
        })
    );
    assert_eq!(
        parse(&args("memory --memory-socket /r/m.sock tiers"), &h),
        Ok(Command::Memory {
            socket: PathBuf::from("/r/m.sock"),
            ask: Ask::Admin(MemoryCommand::Tiers, String::new())
        })
    );
    assert_eq!(parse(&args("memory tiers extra"), &h), Err(UsageError));
}

#[test]
fn memory_tiers_prints_the_reply() {
    let d = temp::TempDir::new("bx-tiers");
    let socket = d.join("admin.sock");
    let listing = "identity  memory.md  hits 0  last -\n  I like tea.\n";
    let seen = fake(
        &socket,
        Message::MemoryAdminReply(MemoryAdminReply {
            text: listing.to_string(),
        }),
    );
    let mut out = Vec::new();
    run(
        &socket,
        &Ask::Admin(MemoryCommand::Tiers, String::new()),
        Duration::from_secs(5),
        &mut out,
    )
    .unwrap();
    assert_eq!(String::from_utf8(out).unwrap(), format!("{listing}\n"));
    match seen.recv().unwrap() {
        Message::MemoryAdmin(m) => {
            assert_eq!((m.command, m.arg.as_str()), (MemoryCommand::Tiers, ""))
        }
        other => panic!("{other:?}"),
    }
}