Function test_to_internal

src/models/rpc.rs:263–439

()

    #[test]
    fn test_to_internal() {
        // Filter with a single column
        let mut column = HashMap::new();
        column.insert(
            "foo".to_string(),
            ComparisonOperator::Eq(MetadataColumnValue::StringValue("hello".to_string())),
        );
        let filter = Filter::Comparison { column };
        let internal = filter.to_internal().unwrap();
        match internal {
            metadata::Filter::Is(pred) => {
                assert_eq!("foo", pred.field_name);
                assert_eq!(
                    pred.field_value,
                    metadata::FieldValue::String("hello".to_string()),
                );
                assert_eq!(pred.operator, metadata::Operator::Equal);
            }
            _ => panic!(),
        }

        // Filter with multiple columns
        let mut column = HashMap::new();
        column.insert(
            "a".to_string(),
            ComparisonOperator::Eq(MetadataColumnValue::StringValue("hello".to_string())),
        );
        column.insert(
            "b".to_string(),
            ComparisonOperator::Ne(MetadataColumnValue::IntValue(2)),
        );
        let filter = Filter::Comparison { column };
        let internal = filter.to_internal().unwrap();
        match internal {
            metadata::Filter::And(preds) => {
                assert_eq!(2, preds.len());
                let p1 = preds.iter().find(|p| p.field_name == "a").unwrap();
                assert_eq!("a", p1.field_name);
                assert_eq!(
                    p1.field_value,
                    metadata::FieldValue::String("hello".to_string()),
                );
                assert_eq!(p1.operator, metadata::Operator::Equal);

                let p2 = preds.iter().find(|p| p.field_name == "b").unwrap();
                assert_eq!("b", p2.field_name);
                assert_eq!(p2.field_value, metadata::FieldValue::Int(2));
                assert_eq!(p2.operator, metadata::Operator::NotEqual);
            }
            _ => panic!(),
        }

        // Filter with Logical::And + single column filters
        let mut c1 = HashMap::new();
        c1.insert(
            "a".to_string(),
            ComparisonOperator::Eq(MetadataColumnValue::StringValue("hello".to_string())),
        );