safe-vk 1.2.0

extern crate safe_vk as vk;

use vk::{
    util::{Filter, TestHardness},
    SafeVk,
};

use std::{io::Write, sync::Arc};
use tokio::sync::Mutex;

async fn mock_command(output: Arc<Mutex<Vec<u8>>>, message: &str) {
    let mut buffer = output.lock().await;
    writeln!(buffer, "{}", message).unwrap();
}

#[tokio::test]
async fn commands() {
    let output = Arc::new(Mutex::new(vec![]));

    let output_command1 = Arc::clone(&output);
    let output_command2 = Arc::clone(&output);

    let test = TestHardness::new(vec![
        TestHardness::dummy_message("/hi"),
        TestHardness::dummy_message("/bye"),
    ]);
    let request = test.dummy_request();

    let bot = SafeVk::new()
        .command(
            "/hi",
            {
                move || {
                    let output_clone_for_async = Arc::clone(&output_command1);
                    async move {
                        mock_command(output_clone_for_async, "hello, world!").await;
                    }
                }
            },
            Filter::Strict,
        )
        .command(
            "/bye",
            {
                move || {
                    let output_clone_for_async = Arc::clone(&output_command2);
                    async move {
                        mock_command(output_clone_for_async, "goodbye, world!").await;
                    }
                }
            },
            Filter::Strict,
        );

    tokio::spawn(async move {
        bot.call_with_state(test.update, (), request.into());
    })
    .await
    .unwrap();

    let captured_output = output.lock().await;
    let captured_output_str = String::from_utf8_lossy(&captured_output);
    assert!(captured_output_str.contains("hello, world!"));
    assert!(captured_output_str.contains("goodbye, world!"));
}