#![cfg(feature = "kramer-async")]

extern crate kramer;

use async_std::prelude::*;

use kramer::{
  execute, read, send, Arity, Command, HashCommand, Insertion, ListCommand, Response, ResponseValue, Side,
  StringCommand,
};
use std::env::var;

#[cfg(test)]
fn set_field<S: std::fmt::Display>(key: S, field: S, value: S) -> Command<S, S> {
  Command::Hashes::<_, _>(HashCommand::Set(key, Arity::One((field, value)), Insertion::Always))
}

#[cfg(test)]
fn arity_single_pair<S: std::fmt::Display>(key: S, value: S) -> Arity<(S, S)> {
  Arity::One((key, value))
}

#[cfg(test)]
fn get_redis_url() -> String {
  let host = var("REDIS_HOST").unwrap_or(String::from("0.0.0.0"));
  let port = var("REDIS_PORT").unwrap_or(String::from("6379"));
  format!("{}:{}", host, port)
}

#[test]
fn test_echo() {
  let url = get_redis_url();
  let result = async_std::task::block_on(send(url.as_str(), Command::Echo::<_, &str>("hello")));
  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String("hello".to_string()))
  );
}

#[test]
fn test_execute() {
  let url = get_redis_url();
  let result = async_std::task::block_on(async {
    let mut stream = async_std::net::TcpStream::connect(url).await?;
    execute(&mut stream, Command::Echo::<_, &str>("hello")).await
  });
  assert_eq!(result.is_ok(), true);
  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("hello")))
  );
}

#[test]
fn test_execute_arc() {
  let url = get_redis_url();
  let stream = async_std::task::block_on(async_std::net::TcpStream::connect(url)).unwrap();
  let arc = async_std::sync::Arc::new(async_std::sync::Mutex::new(stream));

  let result = async_std::task::block_on(async {
    let (a, b) = (arc.clone(), arc.clone());

    let one = async_std::task::spawn(async move {
      let mut conn = a.lock().await;
      execute(&mut (*conn), Command::Echo::<_, &str>("hello")).await
    });

    let two = async_std::task::spawn(async move {
      let mut conn = b.lock().await;
      execute(&mut (*conn), Command::Echo::<_, &str>("world")).await
    });

    (one.await.unwrap(), two.await.unwrap())
  });

  assert_eq!(
    result,
    (
      Response::Item(ResponseValue::String(String::from("hello"))),
      Response::Item(ResponseValue::String(String::from("world")))
    )
  );
}

#[cfg(all(test, feature = "kramer-async-read"))]
#[test]
fn test_async_read_fmt() {
  async_std::task::block_on(async {
    let mut writer = Vec::with_capacity(1000);
    let mut reader = Command::Strings(StringCommand::Set(
      Arity::One(("four", b"hi".into_iter().enumerate())),
      None,
      Insertion::Always,
    ));
    async_std::io::copy(&mut reader, &mut writer)
      .await
      .expect("unable to copy");
    let parsed = String::from_utf8(writer);

    assert_eq!(parsed, Ok("*3\r\n$3\r\nSET\r\n$4\r\nfour\r\n$2\r\nhi\r\n".to_string()));
  });
}

#[cfg(all(test, feature = "kramer-async-read"))]
#[test]
fn test_async_read_exec() {
  async_std::task::block_on(async {
    let mut reader = Command::Strings(StringCommand::Set(
      Arity::One(("four", b"hi".into_iter().enumerate())),
      None,
      Insertion::Always,
    ));
    let url = get_redis_url();
    let mut stream = async_std::net::TcpStream::connect(url).await.unwrap();
    async_std::io::copy(&mut reader, &mut stream).await.unwrap();
    let res = read(&mut stream).await.expect("read response from redis");
    assert_eq!(res, Response::Item(ResponseValue::String("OK".to_string())));
  });
}

#[cfg(all(test, feature = "kramer-async-read"))]
#[test]
fn test_async_read_exec_impl() {
  async_std::task::block_on(async {
    let mut reader = Command::Strings(StringCommand::Set(
      Arity::One(("four", b"hi".into_iter().enumerate())),
      None,
      Insertion::Always,
    ));
    let url = get_redis_url();
    let mut stream = async_std::net::TcpStream::connect(url).await.unwrap();
    let res = reader.execute(&mut stream).await.unwrap();
    assert_eq!(res, Response::Item(ResponseValue::String("OK".to_string())));
  });
}

#[cfg(all(test, feature = "kramer-async-read"))]
#[test]
fn test_async_read_exec_impl_lpush() {
  async_std::task::block_on(async {
    let mut reader = Command::Lists(ListCommand::Push(
      (Side::Right, Insertion::Always),
      "four-r",
      Arity::One(b"hi".into_iter().enumerate()),
    ));
    let url = get_redis_url();
    let mut stream = async_std::net::TcpStream::connect(url).await.unwrap();
    execute(&mut stream, Command::<&str, &str>::Del(Arity::One("four-r")))
      .await
      .expect("cannot clean");
    let res = reader.execute(&mut stream).await.unwrap();
    assert_eq!(res, Response::Item(ResponseValue::Integer(1)));
  });
}

#[cfg(all(test, feature = "kramer-async-read"))]
#[test]
fn test_async_read_exec_impl_rpush() {
  async_std::task::block_on(async {
    let mut reader = Command::Lists(ListCommand::Push(
      (Side::Left, Insertion::Always),
      "four-l",
      Arity::One(b"hi".into_iter().enumerate()),
    ));
    let url = get_redis_url();
    let mut stream = async_std::net::TcpStream::connect(url).await.unwrap();
    execute(&mut stream, Command::<&str, &str>::Del(Arity::One("four-l")))
      .await
      .expect("cannot clean");
    let res = reader.execute(&mut stream).await.unwrap();
    assert_eq!(res, Response::Item(ResponseValue::Integer(1)));
  });
}

#[test]
fn test_execute_nested() {
  let result = async_std::task::block_on(async {
    async_std::task::spawn(async {
      let url = get_redis_url();
      send(url.as_str(), Command::Echo::<_, &str>("hello")).await
    })
    .await
  });
  assert_eq!(result.is_ok(), true);
  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("hello")))
  );
}

#[test]
fn test_send_keys() {
  let url = get_redis_url();
  let result = async_std::task::block_on(send(url.as_str(), Command::Keys::<_, &str>("*")));
  assert!(result.is_ok());
}

#[test]
fn test_set_vanilla() {
  let url = get_redis_url();
  let key = "test_set_vanilla";
  let result = async_std::task::block_on(async {
    let set_result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(Arity::One((key, "kramer")), None, Insertion::Always)),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });
  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("OK")))
  )
}

#[test]
fn test_set_if_not_exists_w_not_exists() {
  let key = "test_set_if_not_exists_w_not_exists";
  let url = get_redis_url();
  let result = async_std::task::block_on(async {
    let set_result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(
        Arity::One((key, "kramer")),
        None,
        Insertion::IfNotExists,
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });
  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("OK")))
  );
}

#[test]
fn test_set_if_not_exists_w_exists() {
  let key = "test_set_if_not_exists_w_exists";
  let url = get_redis_url();

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(Arity::One((key, "kramer")), None, Insertion::Always)),
    )
    .await?;
    let set_result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(
        arity_single_pair(key, "jerry"),
        None,
        Insertion::IfNotExists,
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });
  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Empty));
}

#[test]
fn test_set_if_exists_w_not_exists() {
  let key = "test_set_if_exists_w_not_exists";
  let url = get_redis_url();

  let result = async_std::task::block_on(async {
    let set_result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(
        arity_single_pair(key, "kramer"),
        None,
        Insertion::IfExists,
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });
  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Empty));
}

#[test]
fn test_set_if_exists_w_exists() {
  let key = "test_set_if_exists_w_exists";
  let url = get_redis_url();
  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(
        arity_single_pair(key, "kramer"),
        None,
        Insertion::Always,
      )),
    )
    .await?;
    let set_result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(
        arity_single_pair(key, "jerry"),
        None,
        Insertion::IfExists,
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });
  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("OK")))
  );
}

#[test]
fn test_set_with_duration() {
  let (key, url) = ("test_set_duration", get_redis_url());

  let result = async_std::task::block_on(async {
    let set_result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(
        arity_single_pair(key, "kramer"),
        Some(std::time::Duration::new(10, 0)),
        Insertion::Always,
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });
  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("OK")))
  )
}

#[test]
fn test_blpush_single() {
  let (key, url) = ("test_lpush_single", get_redis_url());

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Left, Insertion::Always),
        key,
        Arity::One("kramer"),
      )),
    )
    .await?;
    let out = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Pop(Side::Left, key, Some((None, 0)))),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from(key)),
      ResponseValue::String(String::from("kramer"))
    ])
  );
}

#[test]
fn test_blpush_blocking() {
  let (key, url) = ("test_lpush_blocking", get_redis_url());

  let handle = async_std::task::spawn(async {
    let cmd = Command::Lists::<_, &str>(ListCommand::Pop(Side::Left, "test_lpush_blocking", Some((None, 0))));
    let url = get_redis_url();
    let dest = url.as_str();
    let mut con = async_std::net::TcpStream::connect(dest).await.expect("foo");
    let f = format!("{}", cmd);
    con.write_all(f.as_bytes()).await.expect("wrote command");
    read(con).await.expect("read response from redis")
  });

  async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Left, Insertion::Always),
        key,
        Arity::One("kramer"),
      )),
    )
    .await
    .expect("pushed");
  });

  let result = async_std::task::block_on(handle);

  assert_eq!(
    result,
    Response::Array(vec![
      ResponseValue::String(String::from(key)),
      ResponseValue::String(String::from("kramer"))
    ])
  );
}

#[test]
fn test_lpush_single() {
  let (key, url) = ("test_lpush_single", get_redis_url());

  let result = async_std::task::block_on(async {
    let out = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Left, Insertion::Always),
        key,
        Arity::One("kramer"),
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_llen_single() {
  let (key, url) = ("test_llen_single", get_redis_url());

  let result = async_std::task::block_on(async {
    let ins = Command::Lists::<_, &str>(ListCommand::Push(
      (Side::Left, Insertion::Always),
      key,
      Arity::One("kramer"),
    ));
    send(url.as_str(), ins).await?;
    let result = send(url.as_str(), Command::Lists::<_, &str>(ListCommand::Len(key))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_lpush_multi() {
  let (key, url) = ("test_lpush_multi", get_redis_url());

  let result = async_std::task::block_on(async {
    let out = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Left, Insertion::Always),
        key,
        Arity::Many(vec!["kramer", "jerry"]),
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(2)));
}

#[test]
fn test_lpushx_single_w_no_exists() {
  let (key, url) = ("test_lpushx_single_w_no_exists", get_redis_url());

  let result = async_std::task::block_on(async {
    let out = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Left, Insertion::IfExists),
        key,
        Arity::One("kramer"),
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(0)));
}

#[test]
fn test_lpushx_single_w_exists() {
  let (key, url) = ("test_lpushx_single_w_exists", get_redis_url());

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Left, Insertion::Always),
        key,
        Arity::One("kramer"),
      )),
    )
    .await?;
    let out = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Left, Insertion::IfExists),
        key,
        Arity::One("kramer"),
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(2)));
}

#[test]
fn test_rpush_single() {
  let (key, url) = ("test_rpush_single", get_redis_url());

  let result = async_std::task::block_on(async {
    let set_result = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Right, Insertion::Always),
        key,
        Arity::One("kramer"),
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_lpop_single() {
  let (key, url) = ("test_lpop_single", get_redis_url());

  let result = async_std::task::block_on(async {
    let push = Command::Lists::<_, &str>(ListCommand::Push(
      (Side::Right, Insertion::Always),
      key,
      Arity::Many(vec!["kramer", "jerry"]),
    ));
    send(url.as_str(), push).await?;
    let result = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Pop(Side::Left, key, None)),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("kramer")))
  );
}

#[test]
fn test_rpop_single() {
  let (key, url) = ("test_rpop_single", get_redis_url());

  let result = async_std::task::block_on(async {
    let push = Command::Lists::<_, &str>(ListCommand::Push(
      (Side::Right, Insertion::Always),
      key,
      Arity::Many(vec!["kramer", "jerry"]),
    ));
    send(url.as_str(), push).await?;
    let result = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Pop(Side::Right, key, None)),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("jerry")))
  );
}

#[test]
fn test_rpush_multiple() {
  let (key, url) = ("test_rpush_many", get_redis_url());

  let result = async_std::task::block_on(async {
    let set_result = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Push(
        (Side::Right, Insertion::Always),
        key,
        Arity::Many(vec!["kramer", "jerry"]),
      )),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(2)));
}

#[test]
fn test_append() {
  let (key, url) = ("test_append", get_redis_url());

  let result = async_std::task::block_on(async {
    let set_result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Append(key, "jerry")),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    set_result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(5)));
}

#[test]
fn test_get() {
  let (key, url) = ("test_get", get_redis_url());

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Append(key, "jerry")),
    )
    .await?;
    let result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Get(Arity::One(key))),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("jerry")))
  );
}

#[test]
fn test_get_multi_append() {
  let (key, url) = ("test_get_multi_append", get_redis_url());

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Append(key, "jerry")),
    )
    .await?;
    send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Append(key, "kramer")),
    )
    .await?;
    let result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Get(Arity::One(key))),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("jerrykramer")))
  );
}

#[test]
fn test_multi_get() {
  let (one, two, url) = ("test_multi_get_1", "test_multi_get_2", get_redis_url());

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Append(one, "jerry")),
    )
    .await?;
    send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Append(two, "kramer")),
    )
    .await?;
    let result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Get(Arity::Many(vec![one, two]))),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(one))).await?;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(two))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from("jerry")),
      ResponseValue::String(String::from("kramer")),
    ]),
  );
}

#[test]
fn test_decr_single() {
  let (key, url) = ("test_decr_single", get_redis_url());

  let result = async_std::task::block_on(async {
    let push = Command::Strings::<_, &str>(StringCommand::Set(arity_single_pair(key, "3"), None, Insertion::Always));
    send(url.as_str(), push).await?;
    let result = send(url.as_str(), Command::Strings::<_, &str>(StringCommand::Decr(key, 1))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(2)));
}

#[test]
fn test_decrby_single() {
  let (key, url) = ("test_decrby_single", get_redis_url());

  let result = async_std::task::block_on(async {
    let push = Command::Strings::<_, &str>(StringCommand::Set(arity_single_pair(key, "3"), None, Insertion::Always));
    send(url.as_str(), push).await?;
    let result = send(url.as_str(), Command::Strings::<_, &str>(StringCommand::Decr(key, 2))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_hset_single() {
  let (key, url) = ("test_hset_single", get_redis_url());

  let result = async_std::task::block_on(async {
    let do_set = Command::Hashes::<_, &str>(HashCommand::Set(key, Arity::One(("name", "kramer")), Insertion::Always));
    let result = send(url.as_str(), do_set).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_hset_multi() {
  let (key, url) = ("test_hset_multi", get_redis_url());

  let result = async_std::task::block_on(async {
    let do_set = Command::Hashes::<_, &str>(HashCommand::Set(
      key,
      Arity::Many(vec![("name", "kramer"), ("friend", "jerry")]),
      Insertion::Always,
    ));
    let result = send(url.as_str(), do_set).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(2)));
}

#[test]
fn test_hdel_single() {
  let (key, url) = ("test_hdel_single", get_redis_url());

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Hashes::<_, &str>(HashCommand::Set(key, Arity::One(("name", "kramer")), Insertion::Always)),
    )
    .await?;
    let del = Command::Hashes::<_, &str>(HashCommand::Del(key, Arity::One("name")));
    let result = send(url.as_str(), del).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_hdel_multi() {
  let (key, url) = ("test_hdel_multi", get_redis_url());

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Hashes::<_, &str>(HashCommand::Set(
        key,
        Arity::Many(vec![("name", "kramer"), ("friend", "jerry")]),
        Insertion::Always,
      )),
    )
    .await?;
    let del = Command::Hashes::<_, &str>(HashCommand::Del(key, Arity::Many(vec!["name", "friend", "foo"])));
    let result = send(url.as_str(), del).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(2)));
}

#[test]
fn test_hsetnx_single_w_no_exists() {
  let (key, url) = ("test_hsetnx_single_w_no_exists", get_redis_url());

  let result = async_std::task::block_on(async {
    let do_set = Command::Hashes::<_, &str>(HashCommand::Set(
      key,
      Arity::One(("name", "kramer")),
      Insertion::IfNotExists,
    ));
    let result = send(url.as_str(), do_set).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_hsetnx_single_w_exists() {
  let (key, url) = ("test_hsetnx_single_w_exists", get_redis_url());

  let result = async_std::task::block_on(async {
    let pre_set = Command::Hashes::<_, &str>(HashCommand::Set(key, Arity::One(("name", "kramer")), Insertion::Always));
    send(url.as_str(), pre_set).await?;
    let do_set = Command::Hashes::<_, &str>(HashCommand::Set(
      key,
      Arity::One(("name", "kramer")),
      Insertion::IfNotExists,
    ));
    let result = send(url.as_str(), do_set).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(0)));
}

#[test]
fn test_hexists_single() {
  let (key, url) = ("test_hexists_single", get_redis_url());

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Hashes::<_, &str>(HashCommand::Set(key, Arity::One(("name", "kramer")), Insertion::Always)),
    )
    .await?;
    let exists = Command::Hashes::<_, &str>(HashCommand::Exists(key, "name"));
    let result = send(url.as_str(), exists).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_hexists_not_found() {
  let (key, url) = ("test_hexists_not_found", get_redis_url());

  let result = async_std::task::block_on(async {
    let exists = Command::Hashes::<_, &str>(HashCommand::Exists(key, "name"));
    let result = send(url.as_str(), exists).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(0)));
}

#[test]
fn test_hgetall_values() {
  let (key, url) = ("test_hgetall_values", get_redis_url());

  let result = async_std::task::block_on(async {
    send(url.as_str(), set_field(key, "name", "kramer")).await?;
    send(url.as_str(), set_field(key, "friend", "jerry")).await?;
    let getall = Command::Hashes::<_, &str>(HashCommand::Get(key, None));
    let result = send(url.as_str(), getall).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from("name")),
      ResponseValue::String(String::from("kramer")),
      ResponseValue::String(String::from("friend")),
      ResponseValue::String(String::from("jerry")),
    ])
  );
}

#[test]
fn test_hgetall_empty() {
  let (key, url) = ("test_hgetall_empty", get_redis_url());

  let result = async_std::task::block_on(async {
    let getall = Command::Hashes::<_, &str>(HashCommand::Get(key, None));
    let result = send(url.as_str(), getall).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Array(vec![]));
}

#[test]
fn test_hget_values() {
  let (key, url) = ("test_hget_values", get_redis_url());

  let result = async_std::task::block_on(async {
    send(url.as_str(), set_field(key, "name", "kramer")).await?;
    let getall = Command::Hashes::<_, &str>(HashCommand::Get(key, Some(Arity::One("name"))));
    let result = send(url.as_str(), getall).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("kramer"))),
  );
}

#[test]
fn test_hmget_values() {
  let (key, url) = ("test_hmget_values", get_redis_url());

  let result = async_std::task::block_on(async {
    send(url.as_str(), set_field(key, "name", "kramer")).await?;
    send(url.as_str(), set_field(key, "friend", "jerry")).await?;
    let getall = Command::Hashes::<_, &str>(HashCommand::Get(key, Some(Arity::Many(vec!["name", "friend"]))));
    let result = send(url.as_str(), getall).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from("kramer")),
      ResponseValue::String(String::from("jerry"))
    ]),
  );
}

#[test]
fn test_hlen_values() {
  let (key, url) = ("test_hlen_values", get_redis_url());

  let result = async_std::task::block_on(async {
    send(url.as_str(), set_field(key, "name", "kramer")).await?;
    let getall = Command::Hashes::<_, &str>(HashCommand::Len(key));
    let result = send(url.as_str(), getall).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_hlen_no_exists() {
  let (key, url) = ("test_hlen_no_exists", get_redis_url());

  let result = async_std::task::block_on(async {
    let hlen = Command::Hashes::<_, &str>(HashCommand::Len(key));
    send(url.as_str(), hlen).await
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(0)));
}

#[test]
fn test_hkeys_values() {
  let (key, url) = ("test_hkeys_values", get_redis_url());

  let result = async_std::task::block_on(async {
    send(url.as_str(), set_field(key, "name", "kramer")).await?;
    let getall = Command::Hashes::<_, &str>(HashCommand::Keys(key));
    let result = send(url.as_str(), getall).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![ResponseValue::String(String::from("name"))])
  );
}

#[test]
fn test_hkeys_no_exists() {
  let (key, url) = ("test_hkeys_no_exists", get_redis_url());

  let result = async_std::task::block_on(async {
    let hlen = Command::Hashes::<_, &str>(HashCommand::Keys(key));
    send(url.as_str(), hlen).await
  });

  assert_eq!(result.unwrap(), Response::Array(vec![]));
}

#[test]
fn test_mset_many() {
  let (one, two, url) = ("test_mset_many_1", "test_mset_many_2", get_redis_url());

  let result = async_std::task::block_on(async {
    let do_set = Command::Strings::<_, &str>(StringCommand::Set(
      Arity::Many(vec![(one, "hello"), (two, "goodbye")]),
      None,
      Insertion::Always,
    ));
    send(url.as_str(), do_set).await?;
    let result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Get(Arity::Many(vec![one, two]))),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(one))).await?;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(two))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from("hello")),
      ResponseValue::String(String::from("goodbye"))
    ]),
  );
}

#[test]
fn test_msetnx_many() {
  let (one, two, url) = ("test_msetnx_many_1", "test_msetnx_many_2", get_redis_url());

  let result = async_std::task::block_on(async {
    let do_set = Command::Strings::<_, &str>(StringCommand::Set(
      Arity::Many(vec![(one, "hello"), (two, "goodbye")]),
      None,
      Insertion::IfNotExists,
    ));
    send(url.as_str(), do_set).await?;
    let result = send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Get(Arity::Many(vec![one, two]))),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(one))).await?;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(two))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from("hello")),
      ResponseValue::String(String::from("goodbye"))
    ]),
  );
}

#[test]
fn test_msetnx_already_exists() {
  let (one, two, url) = (
    "test_msetnx_alredy_exits_1",
    "test_msetnx_already_exists_2",
    get_redis_url(),
  );

  let result = async_std::task::block_on(async {
    send(
      url.as_str(),
      Command::Strings::<_, &str>(StringCommand::Set(Arity::One((one, "foo")), None, Insertion::Always)),
    )
    .await?;
    let do_set = Command::Strings::<_, &str>(StringCommand::Set(
      Arity::Many(vec![(one, "hello"), (two, "goodbye")]),
      None,
      Insertion::IfNotExists,
    ));
    let result = send(url.as_str(), do_set).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(one))).await?;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(two))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(0)),);
}

#[test]
fn test_hvals_values() {
  let (key, url) = ("test_hvals_values", get_redis_url());

  let result = async_std::task::block_on(async {
    send(url.as_str(), set_field(key, "name", "kramer")).await?;
    let getall = Command::Hashes::<_, &str>(HashCommand::Vals(key));
    let result = send(url.as_str(), getall).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![ResponseValue::String(String::from("kramer"))])
  );
}

#[test]
fn test_hstrlen_values() {
  let (key, url) = ("test_hstrlen_values", get_redis_url());

  let result = async_std::task::block_on(async {
    send(url.as_str(), set_field(key, "name", "kramer")).await?;
    let getall = Command::Hashes::<_, &str>(HashCommand::StrLen(key, "name"));
    let result = send(url.as_str(), getall).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(6)));
}

#[test]
fn test_hincrby() {
  let (key, url) = ("test_hincrby", get_redis_url());

  let result = async_std::task::block_on(async {
    send(url.as_str(), set_field(key, "episodes", "10")).await?;
    let inc = Command::Hashes::<_, &str>(HashCommand::Incr(key, "episodes", 10));
    send(url.as_str(), inc).await?;
    let result = send(
      url.as_str(),
      Command::Hashes::<_, &str>(HashCommand::Get(key, Some(Arity::One("episodes")))),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    result
  });

  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("20")))
  );
}

#[test]
fn test_lrange() {
  let (key, url) = ("test_lrange", get_redis_url());

  let result = async_std::task::block_on(async {
    let ins = Command::Lists::<_, &str>(ListCommand::Push(
      (Side::Left, Insertion::Always),
      key,
      Arity::One("kramer"),
    ));
    send(url.as_str(), ins).await?;
    let out = send(url.as_str(), Command::Lists::<_, &str>(ListCommand::Range(key, 0, 10))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![ResponseValue::String(String::from("kramer"))])
  );
}

#[test]
fn test_lindex_present() {
  let (key, url) = ("test_lindex_present", get_redis_url());

  let result = async_std::task::block_on(async {
    let ins = Command::Lists::<_, &str>(ListCommand::Push(
      (Side::Left, Insertion::Always),
      key,
      Arity::One("kramer"),
    ));
    send(url.as_str(), ins).await?;
    let out = send(url.as_str(), Command::Lists::<_, &str>(ListCommand::Index(key, 0))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(
    result.unwrap(),
    Response::Item(ResponseValue::String(String::from("kramer")))
  );
}

#[test]
fn test_lindex_missing() {
  let (key, url) = ("test_lindex_missing", get_redis_url());

  let result = async_std::task::block_on(async {
    let out = send(url.as_str(), Command::Lists::<_, &str>(ListCommand::Index(key, 0))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Empty));
}

#[test]
fn test_lrem_present() {
  let (key, url) = ("test_lrem_present", get_redis_url());

  let result = async_std::task::block_on(async {
    let ins = Command::Lists::<_, &str>(ListCommand::Push(
      (Side::Left, Insertion::Always),
      key,
      Arity::One("kramer"),
    ));
    send(url.as_str(), ins).await?;
    let out = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Rem(key, "kramer", 1)),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(1)));
}

#[test]
fn test_lrem_missing() {
  let (key, url) = ("test_lrem_missing", get_redis_url());

  let result = async_std::task::block_on(async {
    let out = send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Rem(key, "kramer", 1)),
    )
    .await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(result.unwrap(), Response::Item(ResponseValue::Integer(0)));
}

#[test]
fn test_ltrim_present() {
  let (key, url) = ("test_ltrim_present", get_redis_url());

  let result = async_std::task::block_on(async {
    let ins = Command::Lists::<_, &str>(ListCommand::Push(
      (Side::Right, Insertion::Always),
      key,
      Arity::Many(vec!["kramer", "jerry", "elaine", "george"]),
    ));
    send(url.as_str(), ins).await?;
    send(url.as_str(), Command::Lists::<_, &str>(ListCommand::Trim(key, 0, 2))).await?;
    let out = send(url.as_str(), Command::Lists::<_, &str>(ListCommand::Range(key, 0, 10))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from("kramer")),
      ResponseValue::String(String::from("jerry")),
      ResponseValue::String(String::from("elaine")),
    ])
  );
}

#[test]
fn test_linsert_left_present() {
  let (key, url) = ("test_linsert_left_present", get_redis_url());

  let result = async_std::task::block_on(async {
    let ins = Command::Lists::<_, &str>(ListCommand::Push(
      (Side::Right, Insertion::Always),
      key,
      Arity::Many(vec!["kramer", "jerry", "elaine", "george"]),
    ));
    send(url.as_str(), ins).await?;
    send(
      url.as_str(),
      Command::Lists::<_, &str>(ListCommand::Insert(key, Side::Left, "george", "newman")),
    )
    .await?;
    let out = send(url.as_str(), Command::Lists::<_, &str>(ListCommand::Range(key, 0, 10))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from("kramer")),
      ResponseValue::String(String::from("jerry")),
      ResponseValue::String(String::from("elaine")),
      ResponseValue::String(String::from("newman")),
      ResponseValue::String(String::from("george")),
    ])
  );
}

#[cfg(feature = "kramer-io")]
#[test]
fn test_linsert_right_present() {
  let (key, url) = ("test_linsert_right_present", get_redis_url());

  let result = async_std::task::block_on(async {
    let ins = Command::Lists(ListCommand::Push(
      (Side::Right, Insertion::Always),
      key,
      Arity::Many(vec!["kramer", "jerry", "elaine", "george"]),
    ));
    send(url.as_str(), ins).await?;
    send(
      url.as_str(),
      Command::Lists(ListCommand::Insert(key, Side::Right, "george", "newman")),
    )
    .await?;
    let out = send(url.as_str(), Command::Lists(ListCommand::Range(key, 0, 10))).await;
    send(url.as_str(), Command::Del::<_, &str>(Arity::One(key))).await?;
    out
  });

  assert_eq!(
    result.unwrap(),
    Response::Array(vec![
      ResponseValue::String(String::from("kramer")),
      ResponseValue::String(String::from("jerry")),
      ResponseValue::String(String::from("elaine")),
      ResponseValue::String(String::from("george")),
      ResponseValue::String(String::from("newman")),
    ])
  );
}