// (C) Copyright 2019-2020 Hewlett Packard Enterprise Development LP

extern crate prometheus_parser;

use prometheus_parser::*;

#[test]
fn parse_selector_subquery() -> Result<()> {
  // not a subquery
  assert_eq!(
    parse_expr(r#"foo[5m]"#)?,
    Selector::new()
      .metric("foo")
      .range(PromDuration::Minutes(5))
      .span((0, 7))
      .wrap()
  );

  // invalid whitespace
  assert_eq!(
    parse_expr(r#"foo[ 5m:]"#).is_err(),
    true
  );

  // valid whitespace
  assert_eq!(
    parse_expr(r#"foo[5m  :  30s   ]"#).is_ok(),
    true
  );

  assert_eq!(
    parse_expr(r#"foo[5m:]"#)?,
    Selector::new()
      .metric("foo")
      .subquery(Subquery::new(PromDuration::Minutes(5))
        .span((3, 8)))
      .span((0, 8))
      .wrap()
  );

  assert_eq!(
    parse_expr(r#"foo[5m:30s]"#)?,
    Selector::new()
      .metric("foo")
      .subquery(Subquery::new(PromDuration::Minutes(5))
        .resolution(PromDuration::Seconds(30))
        .span((3, 11)))
      .span((0, 11))
      .wrap()
  );

  Ok(())
}

#[test]
fn parse_group_subquery() -> Result<()> {
  assert_eq!(
    parse_expr(r#"(foo)[5m]"#).is_err(),
    true
  );

  assert_eq!(
    parse_expr(r#"(foo)[5m:]"#)?,
    Group::new(
      Selector::new().metric("foo").span((1, 4)).wrap()
    ).subquery(
      Subquery::new(PromDuration::Minutes(5)).span((5, 10))
    ).span((0, 10)).wrap()
  );

  Ok(())
}

#[test]
fn parse_function_subquery() -> Result<()> {
  // not a subquery
  assert_eq!(
    parse_expr(r#"sum(foo)[5m]"#).is_err(),
    true
  );

  // invalid whitespace
  assert_eq!(
    parse_expr(r#"sum(foo)[ 5m:]"#).is_err(),
    true
  );

  // valid whitespace
  assert_eq!(
    parse_expr(r#"sum(foo)[5m  :  30s   ]"#).is_ok(),
    true
  );

  assert_eq!(
    parse_expr(r#"sum(foo)[5m:]"#)?,
    Function::new("sum")
      .arg(Selector::new()
        .metric("foo")
        .span((4, 7))
        .wrap()
      )
      .subquery(Subquery::new(PromDuration::Minutes(5)).span((8, 13)))
      .span((0, 13))
      .wrap()
  );

  assert_eq!(
    parse_expr(r#"sum(foo)[5m:30s]"#)?,
    Function::new("sum")
      .arg(Selector::new()
        .metric("foo")
        .span((4, 7))
        .wrap()
      )
      .subquery(Subquery::new(PromDuration::Minutes(5))
        .resolution(PromDuration::Seconds(30))
        .span((8, 16)))
      .span((0, 16))
      .wrap()
  );

  Ok(())
}

#[test]
fn return_value_subquery() -> Result<()> {
  assert_eq!(
    parse_expr(r#"(foo)"#)?.return_value(),
    ReturnValue {
      kind: ReturnKind::InstantVector,
      label_ops: vec![]
    }
  );

  assert_eq!(
    parse_expr(r#"(foo)[5m:30s]"#)?.return_value(),
    ReturnValue {
      kind: ReturnKind::RangeVector,
      label_ops: vec![]
    }
  );

  // subquery on a range vector isn't allowed
  assert_eq!(
    parse_expr(r#"(foo[5m])[5m:30s]"#)?.return_value(),
    ReturnValue {
      kind: ReturnKind::unknown(
        "subquery on inner expression returning RangeVector is invalid",
        parse_expr(r#"(foo[5m])[5m:30s]"#)?
      ),
      label_ops: vec![]
    }
  );

  let expr = parse_expr(r#"sum(foo)"#)?;
  assert_eq!(
    expr.return_value(),
    ReturnValue {
      kind: ReturnKind::InstantVector,
      label_ops: vec![LabelSetOp::clear(expr.clone(), Some(Span {
        start: 0,
        end: 8
      }))]
    }
  );

  let expr = parse_expr(r#"sum(foo)[5m:]"#)?;
  assert_eq!(
    expr.return_value(),
    ReturnValue {
      kind: ReturnKind::RangeVector,
      label_ops: vec![LabelSetOp::clear(expr.clone(), Some(Span {
        start: 0,
        end: 13
      }))]
    }
  );

  Ok(())
}