# proto-file: ../../../proto/cel/expr/conformance/test/simple.proto
# proto-message: google.api.expr.test.v1.SimpleTestFile

name: "macros"
description: "Tests for CEL macros."
section {
  name: "exists"
  description: "Tests for the .exists() macro, which is equivalent to joining the evaluated elements with logical-OR."
  test {
    name: "list_elem_all_true"
    expr: "[1, 2, 3].exists(e, e > 0)"
    value: { bool_value: true }
  }
  test {
    name: "list_elem_some_true"
    expr: "[1, 2, 3].exists(e, e == 2)"
    value: { bool_value: true }
  }
  test {
    name: "list_elem_none_true"
    expr: "[1, 2, 3].exists(e, e > 3)"
    value: { bool_value: false }
  }
  test {
    name: "list_elem_type_shortcircuit"
    description: "Exists filter is true for the last element."
    expr: "[1, 'foo', 3].exists(e, e != '1')"
    value: { bool_value: true }
  }
  test {
    name: "list_elem_type_exhaustive"
    description: "Exists filter is never true, but heterogenous equality ensure the result is false."
    expr: "[1, 'foo', 3].exists(e, e == '10')"
    value: { bool_value: false }
  }
  test {
    name: "list_elem_exists_error"
    expr: "[1, 2, 3].exists(e, e / 0 == 17)"
    eval_error: {
      errors: { message: "divide by zero" }
    }
  }
  test {
    name: "list_empty"
    expr: "[].exists(e, e == 2)"
    value: { bool_value: false }
  }
  test {
    name: "map_key"
    expr: "{'key1':1, 'key2':2}.exists(k, k == 'key2')"
    value: { bool_value: true }
  }
  test {
    name: "not_map_key"
    expr: "!{'key1':1, 'key2':2}.exists(k, k == 'key3')"
    value: { bool_value: true }
  }
  test {
    name: "map_key_type_shortcircuit"
    description: "Exists filter is true for the second key"
    expr: "{'key':1, 1:21}.exists(k, k != 2)"
    value: { bool_value: true }
  }
  test {
    name: "map_key_type_exhaustive"
    description: "Exists filter is never true, but heterogeneous equality ensures the result is false."
    expr: "!{'key':1, 1:42}.exists(k, k == 2)"
    value: { bool_value: true }
  }
}
section {
  name: "all"
  description: "Tests for the .all() macro, which is equivalent to joining the evaluated elements with logical-AND."
  test {
    name: "list_elem_all_true"
    expr: "[1, 2, 3].all(e, e > 0)"
    value: { bool_value: true }
  }
  test {
    name: "list_elem_some_true"
    expr: "[1, 2, 3].all(e, e == 2)"
    value: { bool_value: false }
  }
  test {
    name: "list_elem_none_true"
    expr: "[1, 2, 3].all(e, e == 17)"
    value: { bool_value: false }
  }
  test {
    name: "list_elem_type_shortcircuit"
    expr: "[1, 'foo', 3].all(e, e == 1)"
    value: { bool_value: false }
  }
  test {
    name: "list_elem_type_exhaustive"
    expr: "[1, 'foo', 3].all(e, e % 2 == 1)"
    eval_error: {
      errors: { message: "no_such_overload" }
    }
  }
  test {
    name: "list_elem_error_shortcircuit"
    expr: "[1, 2, 3].all(e, 6 / (2 - e) == 6)"
    value: { bool_value: false }
  }
  test {
    name: "list_elem_error_exhaustive"
    expr: "[1, 2, 3].all(e, e / 0 != 17)"
    eval_error: {
      errors: { message: "divide by zero" }
    }
  }
  test {
    name: "list_empty"
    expr: "[].all(e, e > 0)"
    value: { bool_value: true }
  }
  test {
    name: "map_key"
    expr: "{'key1':1, 'key2':2}.all(k, k == 'key2')"
    value: { bool_value: false }
  }
}
section {
  name: "exists_one"
  description: "Tests for exists_one() macro. An expression 'L.exists_one(I, E)' is equivalent to 'size(L.filter(I, E)) == 1'."
  test {
    name: "list_empty"
    expr: "[].exists_one(a, a == 7)"
    value: { bool_value: false }
  }
  test {
    name: "list_one_true"
    expr: "[7].exists_one(a, a == 7)"
    value: { bool_value: true }
  }
  test {
    name: "list_one_false"
    expr: "[8].exists_one(a, a == 7)"
    value: { bool_value: false }
  }
  test {
    name: "list_none"
    expr: "[1, 2, 3].exists_one(x, x > 20)"
    value: { bool_value: false }
  }
  test {
    name: "list_one"
    expr: "[6, 7, 8].exists_one(foo, foo % 5 == 2)"
    value: { bool_value: true }
  }
  test {
    name: "list_many"
    expr: "[0, 1, 2, 3, 4].exists_one(n, n % 2 == 1)"
    value: { bool_value: false }
  }
  test {
    name: "list_all"
    expr: "['foal', 'foo', 'four'].exists_one(n, n.startsWith('fo'))"
    value: { bool_value: false }
  }
  test {
    name: "list_no_shortcircuit"
    description: "Errors invalidate everything, even if already false."
    expr: "[3, 2, 1, 0].exists_one(n, 12 / n > 1)"
    eval_error {
      errors: { message: "divide by zero" }
    }
  }
  test {
    name: "map_one"
    expr: "{6: 'six', 7: 'seven', 8: 'eight'}.exists_one(foo, foo % 5 == 2)"
    value: { bool_value: true }
  }
}
section {
  name: "map"
  description: "Tests for map() macro."
  test {
    name: "list_empty"
    expr: "[].map(n, n / 2)"
    value: { list_value: {} }
  }
  test {
    name: "list_one"
    expr: "[3].map(n, n * n)"
    value: { list_value {
        values: { int64_value: 9 }
      }
    }
  }
  test {
    name: "list_many"
    expr: "[2, 4, 6].map(n, n / 2)"
    value: { list_value {
        values: { int64_value: 1 }
        values: { int64_value: 2 }
        values: { int64_value: 3 }
      }
    }
  }
  test {
    name: "list_error"
    expr: "[2, 1, 0].map(n, 4 / n)"
    eval_error {
      errors: { message: "divide by zero" }
    }
  }
  test {
    name: "map_extract_keys"
    expr: "{'John': 'smart'}.map(key, key) == ['John']"
    value: { bool_value: true }
  }
}
section {
  name: "filter"
  description: "Tests for filter() macro."
  test {
    name: "list_empty"
    expr: "[].filter(n, n % 2 == 0)"
    value: { list_value {} }
  }
  test {
    name: "list_one_true"
    expr: "[2].filter(n, n == 2)"
    value: { list_value {
        values: { int64_value: 2 }
      }
    }
  }
  test {
    name: "list_one_false"
    expr: "[1].filter(n, n > 3)"
    value: { list_value {} }
  }
  test {
    name: "list_none"
    expr: "[1, 2, 3].filter(e, e > 3)"
    value: { list_value {} }
  }
  test {
    name: "list_some"
    expr: "[0, 1, 2, 3, 4].filter(x, x % 2 == 1)"
    value: { list_value {
        values: { int64_value: 1 }
        values: { int64_value: 3 }
      }
    }
  }
  test {
    name: "list_all"
    expr: "[1, 2, 3].filter(n, n > 0)"
    value: { list_value {
        values: { int64_value: 1 }
        values: { int64_value: 2 }
        values: { int64_value: 3 }
      }
    }
  }
  test {
    name: "list_no_shortcircuit"
    expr: "[3, 2, 1, 0].filter(n, 12 / n > 4)"
    eval_error {
      errors: { message: "divide by zero" }
    }
  }
  test {
    name: "map_filter_keys"
    expr: "{'John': 'smart', 'Paul': 'cute', 'George': 'quiet', 'Ringo': 'funny'}.filter(key, key == 'Ringo') == ['Ringo']"
    value: { bool_value: true }
  }
}
section {
  name: "nested"
  description: "Tests with nested macros."
  test {
    name: "filter_all"
    expr: "['signer'].filter(signer, ['artifact'].all(artifact, true))"
    value: { list_value {
        values: { string_value: "signer" }
      }
    }
  }
  test {
    name: "all_all"
    expr: "['signer'].all(signer, ['artifact'].all(artifact, true))"
    value: { bool_value: true }
  }
}