Function test_input_field_combinations

src/metadata/schema.rs:611–726

()

    #[test]
    fn test_input_field_combinations() {
        let a_values: HashSet<FieldValue> = (1..=10).map(FieldValue::Int).collect();
        let a = MetadataField::new("a".to_owned(), a_values).unwrap();

        let b_values: HashSet<FieldValue> = (1..=10).map(FieldValue::Int).collect();
        let b = MetadataField::new("b".to_owned(), b_values).unwrap();

        let c_values: HashSet<FieldValue> = (1..=10).map(FieldValue::Int).collect();
        let c = MetadataField::new("c".to_owned(), c_values).unwrap();

        let conditions = vec![
            SupportedCondition::And(hashset(vec!["a", "b"])),
            SupportedCondition::And(hashset(vec!["a", "c"])),
            SupportedCondition::Or(hashset(vec!["a", "b"])),
        ];

        let schema = MetadataSchema::new(vec![a, b, c], conditions).unwrap();

        // Test case 1: As the input contains only a single field,
        // only the following replicas are relevant to this vector:
        //
        //  1. matches "a"
        //
        // Hence the result is 1 combination i.e. 1 replica
        let fs = ifc_input(vec![("a", 1)]);
        let cs = schema.input_field_combinations(&fs);
        assert_eq!(1, cs.len());
        let mut ec1 = HashMap::with_capacity(1);
        ec1.insert("a", &FieldValue::Int(1));
        assert_eq!(ec1, cs[0]);

        // Test case 2: As the input contains only "a" and "b", only
        // the following replicas are relevant to this vector
        //
        //   1. matches "a"
        //   2. matches "b"
        //   3. matches "a AND b"
        //
        // Hence the result is 3 combinations i.e. 3 replicas.
        let fs = ifc_input(vec![("a", 1), ("b", 2)]);
        let mut cs = schema.input_field_combinations(&fs);

        // To make the order of returned combinations deterministic,
        // sort them by sum of the field values.
        ifc_sort_result(&mut cs);

        assert_eq!(3, cs.len());
        let mut ec1 = HashMap::with_capacity(1);
        ec1.insert("a", &FieldValue::Int(1));
        let mut ec2 = HashMap::with_capacity(1);
        ec2.insert("b", &FieldValue::Int(2));
        let mut ec3 = HashMap::with_capacity(2);
        ec3.insert("a", &FieldValue::Int(1));
        ec3.insert("b", &FieldValue::Int(2));
        assert_eq!(vec![ec1, ec2, ec3], cs);

        // Test case 3: The input contains fields "b" and "c"
        // only. There is no supported `AND` condition that includes